การจำลองแบบข้ามระหว่าง PostgreSQL และ MySQL

ฉันจะสรุปการจำลองแบบข้ามระหว่าง PostgreSQL และ MySQL รวมถึงวิธีการตั้งค่าการจำลองแบบข้ามระหว่างเซิร์ฟเวอร์ฐานข้อมูลทั้งสอง โดยทั่วไปแล้ว ฐานข้อมูลที่จำลองแบบข้ามจะเรียกว่าเป็นเนื้อเดียวกัน และเป็นวิธีที่สะดวกในการย้ายจากเซิร์ฟเวอร์ RDBMS หนึ่งไปยังอีกเซิร์ฟเวอร์หนึ่ง

โดยทั่วไปแล้วฐานข้อมูล PostgreSQL และ MySQL ถือเป็นฐานข้อมูลเชิงสัมพันธ์ แต่ด้วยส่วนขยายเพิ่มเติม จึงทำให้มีความสามารถ NoSQL ได้ ที่นี่เราจะหารือเกี่ยวกับการจำลองแบบระหว่าง PostgreSQL และ MySQL จากมุมมองของ DBMS เชิงสัมพันธ์

เราจะไม่อธิบายการทำงานภายในทั้งหมดเพียงหลักการพื้นฐานเพื่อให้คุณได้รับแนวคิดในการกำหนดค่าการจำลองแบบระหว่างเซิร์ฟเวอร์ฐานข้อมูล ข้อดี ข้อจำกัด และกรณีการใช้งาน

โดยทั่วไปแล้ว การจำลองแบบระหว่างเซิร์ฟเวอร์ฐานข้อมูลที่เหมือนกันสองเซิร์ฟเวอร์จะทำในโหมดไบนารี่หรือใช้การสืบค้นระหว่างต้นแบบ (หรือที่เรียกว่าผู้เผยแพร่ ต้นแบบ หรือที่ใช้งานอยู่) และทาส (สมาชิก สแตนด์บาย หรือแฝง) วัตถุประสงค์ของการจำลองแบบคือเพื่อให้สำเนาแบบเรียลไทม์ของฐานข้อมูลหลักบนฝั่งสเลฟ ในกรณีนี้ ข้อมูลจะถูกถ่ายโอนจากต้นแบบไปยังทาส กล่าวคือ จากแอ็คทีฟไปเป็นพาสซีฟ เนื่องจากการจำลองแบบจะดำเนินการในทิศทางเดียวเท่านั้น แต่คุณสามารถตั้งค่าการจำลองแบบระหว่างสองฐานข้อมูลในทั้งสองทิศทางได้ เพื่อให้ข้อมูลถูกถ่ายโอนจากทาสไปยังฐานข้อมูลหลักในการกำหนดค่าที่ใช้งานอยู่ ทั้งหมดนี้ รวมถึงการจำลองแบบเรียงซ้อนเป็นไปได้ระหว่างเซิร์ฟเวอร์ฐานข้อมูลที่เหมือนกันตั้งแต่ XNUMX ตัวขึ้นไป การกำหนดค่าแบบ Active-active หรือ Active-Passive ขึ้นอยู่กับความต้องการ ความพร้อมใช้งานของความสามารถดังกล่าวในการกำหนดค่าเริ่มต้นหรือการใช้โซลูชันการกำหนดค่าภายนอกและข้อดีข้อเสียที่มีอยู่

การกำหนดค่าที่อธิบายไว้เป็นไปได้ระหว่างเซิร์ฟเวอร์ฐานข้อมูลที่แตกต่างกัน สามารถกำหนดค่าเซิร์ฟเวอร์ให้ยอมรับข้อมูลที่จำลองแบบจากเซิร์ฟเวอร์ฐานข้อมูลอื่นและยังคงรักษาสแนปชอตแบบเรียลไทม์ของข้อมูลที่จำลองแบบ MySQL และ PostgreSQL นำเสนอการกำหนดค่าเหล่านี้ส่วนใหญ่ภายในองค์กรหรือผ่านส่วนขยายของบุคคลที่สาม รวมถึงวิธีการบันทึกไบนารี การล็อคดิสก์ และวิธีการตามคำสั่งและแถว

การจำลองแบบข้ามระหว่าง MySQL และ PostgreSQL เป็นสิ่งจำเป็นสำหรับการย้ายแบบครั้งเดียวจากเซิร์ฟเวอร์ฐานข้อมูลหนึ่งไปยังอีกเซิร์ฟเวอร์หนึ่ง ฐานข้อมูลเหล่านี้ใช้โปรโตคอลที่แตกต่างกัน ดังนั้นจึงไม่สามารถเชื่อมโยงโดยตรงได้ หากต้องการสร้างการแลกเปลี่ยนข้อมูล คุณสามารถใช้เครื่องมือโอเพ่นซอร์สภายนอก เช่น pg_chameleon

pg_chameleon คืออะไร

pg_chameleon คือระบบการจำลองแบบตั้งแต่ MySQL ไปจนถึง PostgreSQL ใน Python 3 โดยจะใช้ไลบรารีการจำลองแบบ mysql แบบโอเพ่นซอร์สใน Python เช่นกัน รูปภาพแถวจะถูกแยกจากตาราง MySQL และจัดเก็บเป็นออบเจ็กต์ JSONB ในฐานข้อมูล PostgreSQL จากนั้นถอดรหัสด้วยฟังก์ชัน pl/pgsql และทำซ้ำในฐานข้อมูล PostgreSQL

คุณสมบัติของ pg_chameleon

สคีมา MySQL หลายรายการจากคลัสเตอร์เดียวกันสามารถจำลองไปยังฐานข้อมูล PostgreSQL เป้าหมายเดียวในการกำหนดค่าแบบหนึ่งต่อกลุ่ม
ชื่อสคีมาต้นทางและเป้าหมายต้องไม่เหมือนกัน
ข้อมูลการจำลองสามารถดึงมาจากแบบจำลอง MySQL แบบเรียงซ้อน
ตารางที่ไม่สามารถทำซ้ำหรือสร้างข้อผิดพลาดได้จะถูกแยกออก
ฟังก์ชันการจำลองแต่ละรายการจะถูกควบคุมโดย daemons
ควบคุมผ่านพารามิเตอร์ที่ใช้ YAML และไฟล์การกำหนดค่า

ตัวอย่าง

โฮสต์
vm1
vm2

เวอร์ชันระบบปฏิบัติการ
CentOS ลินุกซ์ 7.6 x86_64
CentOS ลินุกซ์ 7.5 x86_64

เวอร์ชันเซิร์ฟเวอร์ฐานข้อมูล
MySQL 5.7.26
PostgreSQL 10.5

พอร์ตดีบี
3306
5433

ที่อยู่ IP
192.168.56.102
192.168.56.106

ในการเริ่มต้น ให้เตรียมส่วนประกอบที่จำเป็นทั้งหมดเพื่อติดตั้ง pg_chameleon ตัวอย่างนี้จะติดตั้ง Python 3.6.8 ซึ่งสร้างและเปิดใช้งานสภาพแวดล้อมเสมือน

$> 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 สำเร็จแล้ว คุณจะต้องปฏิบัติตามข้อกำหนดที่เหลือ เช่น การสร้างและเปิดใช้งานสภาพแวดล้อมเสมือน นอกจากนี้ โมดูล 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 จะมีส่วนของการตั้งค่าส่วนกลาง ซึ่งคุณสามารถจัดการการตั้งค่า เช่น ตำแหน่งของไฟล์ล็อค ตำแหน่งของบันทึก ระยะเวลาการจัดเก็บบันทึก ฯลฯ ถัดมาคือส่วนแทนที่ประเภท โดยที่ ชุดกฎสำหรับการแทนที่ประเภทในระหว่างการจำลองแบบ ตัวอย่างนี้ใช้ค่าเริ่มต้นเป็นกฎการแทนที่ประเภทที่แปลง Tinyint(1) ให้เป็นค่าบูลีน ในส่วนถัดไป เราจะระบุรายละเอียดการเชื่อมต่อกับฐานข้อมูลเป้าหมาย ในกรณีของเรา นี่คือฐานข้อมูล PostgreSQL ที่กำหนดว่า pg_conn ในส่วนสุดท้าย เราจะระบุข้อมูลต้นทาง นั่นคือ พารามิเตอร์การเชื่อมต่อของฐานข้อมูลต้นทาง รูปแบบการแมประหว่างฐานข้อมูลต้นทางและเป้าหมาย ตารางที่ต้องข้าม เวลารอ หน่วยความจำ ขนาดแพ็คเกจ โปรดทราบว่า "แหล่งที่มา" เป็นพหูพจน์ ซึ่งหมายความว่าเราสามารถเพิ่มฐานข้อมูลแหล่งที่มาหลายฐานข้อมูลลงในฐานข้อมูลเป้าหมายเดียวเพื่อตั้งค่าการกำหนดค่าแบบหลายต่อหนึ่งได้

ฐานข้อมูลตัวอย่าง world_x มี 4 ตารางพร้อมแถวที่ชุมชน MySQL นำเสนอเป็นตัวอย่าง ก็สามารถดาวน์โหลดได้ ที่นี่. ฐานข้อมูลตัวอย่างมาในรูปแบบไฟล์ tar และไฟล์บีบอัดพร้อมคำแนะนำในการสร้างและนำเข้าแถว

ในฐานข้อมูล 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 ได้รับการกำหนดค่าโดยอัตโนมัติเป็นเจ้าของสคีมาสองตัว ได้แก่ 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:

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

คำสั่ง pg_chameleon (chameleon) สามคำสั่งถัดไปจะเตรียมสภาพแวดล้อม เพิ่มแหล่งที่มา และเตรียมข้อมูลเบื้องต้นให้กับเรพลิกา อาร์กิวเมนต์ create_replica_schema สำหรับ pg_chameleon จะสร้างสคีมาเริ่มต้น (sch_chameleon) และสคีมาการจำลอง (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 และข้อผิดพลาดสามารถดูได้โดยใช้อาร์กิวเมนต์ show_errors

ผล

ดังที่เราได้กล่าวไปแล้ว แต่ละฟังก์ชันการจำลองแบบจะถูกควบคุมโดย daemons หากต้องการดู เราจะสอบถามตารางกระบวนการด้วยคำสั่ง Linux ps ดังที่แสดงด้านล่าง

ผล

การจำลองจะไม่ถือว่าได้รับการกำหนดค่าจนกว่าเราจะทดสอบแบบเรียลไทม์ ดังที่แสดงด้านล่าง เราสร้างตาราง แทรกบันทึกสองสามรายการลงในฐานข้อมูล MySQL และเรียกอาร์กิวเมนต์ sync_tables ใน pg_chameleon เพื่ออัปเดต daemons และจำลองตารางด้วยบันทึกไปยังฐานข้อมูล 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 ต่อไปนี้จะเป็นจุดสิ้นสุดของมัน จำเป็นต้องดำเนินการคำสั่งหลังจากที่เราแน่ใจว่าแถวของตารางเป้าหมายทั้งหมดได้รับการจำลองแบบแล้ว และผลลัพธ์จะเป็นฐานข้อมูล PostgreSQL ที่ได้รับการโยกย้ายอย่างเรียบร้อยโดยไม่มีการอ้างอิงถึงฐานข้อมูลต้นทางหรือรูปแบบการจำลองแบบ (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 เท่านั้น ดังนั้นจึงเหมาะสำหรับวงจร "แอคทีฟ-พาสซีฟ" เท่านั้น
แหล่งที่มาสามารถเป็นฐานข้อมูล MySQL เท่านั้น และการรองรับฐานข้อมูล PostgreSQL ในฐานะแหล่งที่มาเป็นเพียงการทดลองและมีข้อจำกัด (เรียนรู้เพิ่มเติม ที่นี่)

ผลลัพธ์สำหรับ pg_chameleon

วิธีการจำลองแบบใน pg_chameleon เหมาะอย่างยิ่งสำหรับการย้ายฐานข้อมูลจาก MySQL ไปยัง PostgreSQL ข้อเสียที่สำคัญคือการจำลองแบบเป็นเพียงทางเดียว ดังนั้นผู้เชี่ยวชาญด้านฐานข้อมูลจึงไม่น่าจะต้องการใช้เพื่อสิ่งอื่นใดนอกจากการย้ายข้อมูล แต่ปัญหาของการจำลองแบบทางเดียวสามารถแก้ไขได้ด้วยเครื่องมือโอเพ่นซอร์สอื่น - SymmetricDS

อ่านเพิ่มเติมในเอกสารอย่างเป็นทางการ ที่นี่. คุณสามารถค้นหาวิธีใช้บรรทัดคำสั่งได้ ที่นี่.

ภาพรวมของ SymmetricDS

SymmetricDS เป็นเครื่องมือโอเพ่นซอร์สที่จำลองฐานข้อมูลใด ๆ ไปยังฐานข้อมูลทั่วไปอื่น ๆ : Oracle, MongoDB, PostgreSQL, MySQL, SQL Server, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird และอินสแตนซ์ฐานข้อมูลคลาวด์อื่น ๆ เช่น Redshift และ Azure ฯลฯ คุณสมบัติที่มีให้ใช้งาน: การซิงโครไนซ์ฐานข้อมูลและไฟล์ การจำลองฐานข้อมูลแบบหลายหลัก การซิงโครไนซ์แบบกรอง การแปลง และอื่นๆ นี่เป็นเครื่องมือ Java และต้องมี JRE หรือ JDK รุ่นมาตรฐาน (เวอร์ชัน 8.0 หรือสูงกว่า) ที่นี่ การเปลี่ยนแปลงข้อมูลทริกเกอร์ในฐานข้อมูลต้นทางสามารถบันทึกและส่งไปยังฐานข้อมูลเป้าหมายที่เหมาะสมในรูปแบบของแบทช์

คุณสมบัติ SymmetricDS

เครื่องมือนี้เป็นอิสระจากแพลตฟอร์ม หมายความว่าฐานข้อมูลที่แตกต่างกันสองฐานข้อมูลขึ้นไปสามารถแลกเปลี่ยนข้อมูลได้
ฐานข้อมูลเชิงสัมพันธ์จะถูกซิงโครไนซ์โดยใช้บันทึกการเปลี่ยนแปลงข้อมูล ในขณะที่ฐานข้อมูลตามระบบไฟล์ใช้การซิงโครไนซ์ไฟล์
การจำลองแบบสองทางโดยใช้วิธี Push and Pull ตามกฎชุดหนึ่ง
การถ่ายโอนข้อมูลสามารถทำได้ผ่านเครือข่ายที่ปลอดภัยและมีแบนด์วิธต่ำ
การกู้คืนอัตโนมัติเมื่อโหนดกลับมาดำเนินการต่อหลังจากเกิดความล้มเหลวและการแก้ไขข้อขัดแย้งอัตโนมัติ
API ส่วนขยายที่เข้ากันได้กับระบบคลาวด์และมีประสิทธิภาพ

ตัวอย่าง

SymmetricDS สามารถกำหนดค่าได้จากหนึ่งในสองตัวเลือก:
โหนดหลัก (พาเรนต์) ที่ประสานการจำลองข้อมูลระหว่างโหนดทาส (ลูก) สองโหนดจากส่วนกลาง และการสื่อสารระหว่างโหนดลูกเกิดขึ้นผ่านพาเรนต์เท่านั้น
โหนดที่ใช้งานอยู่ (โหนด 1) สามารถสื่อสารเพื่อการจำลองแบบกับโหนดที่ใช้งานอยู่อื่น (โหนด 2) โดยไม่ต้องมีคนกลาง

ในทั้งสองตัวเลือก การแลกเปลี่ยนข้อมูลจะเกิดขึ้นโดยใช้การกดและดึง ในตัวอย่างนี้ เราจะพิจารณาการกำหนดค่าแบบแอคทีฟ-แอคทีฟ การอธิบายสถาปัตยกรรมทั้งหมดอาจใช้เวลานานเกินไป ดังนั้นคุณควรค้นคว้าข้อมูลให้ดี ความเป็นผู้นำเพื่อเรียนรู้เพิ่มเติมเกี่ยวกับอุปกรณ์ SymmetricDS

การติดตั้ง SymmetricDS นั้นง่ายมาก: ดาวน์โหลดไฟล์ zip เวอร์ชันโอเพ่นซอร์ส ด้วยเหตุนี้ และนำมันออกไปทุกที่ที่คุณต้องการ ตารางด้านล่างให้ข้อมูลเกี่ยวกับตำแหน่งการติดตั้งและเวอร์ชันของ SymmetricDS ในตัวอย่างนี้ รวมถึงเวอร์ชันฐานข้อมูล เวอร์ชัน Linux ที่อยู่ IP และพอร์ตสำหรับทั้งสองโหนด

โฮสต์
vm1
vm2

เวอร์ชันระบบปฏิบัติการ
CentOS ลินุกซ์ 7.6 x86_64
CentOS ลินุกซ์ 7.6 x86_64

เวอร์ชันเซิร์ฟเวอร์ฐานข้อมูล
MySQL 5.7.26
PostgreSQL 10.5

พอร์ตดีบี
3306
5832

ที่อยู่ IP
192.168.1.107
192.168.1.112

เวอร์ชัน SymmetricDS
สมมาตร DS 3.9
สมมาตร DS 3.9

เส้นทางการติดตั้ง SymmetricDS
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20

ชื่อโหนด SymmetricDS
คอร์ป-000
ร้าน-001

ที่นี่เราติดตั้ง SymmetricDS ใน /usr/local/symmetric-server-3.9.20 และไดเรกทอรีย่อยและไฟล์ต่างๆ จะถูกจัดเก็บไว้ที่นั่น เราสนใจไดเร็กทอรีย่อยตัวอย่างและเอ็นจิ้น ไดเร็กทอรีตัวอย่างประกอบด้วยไฟล์การกำหนดค่าตัวอย่างที่มีคุณสมบัติโหนด รวมถึงตัวอย่างสคริปต์ SQL เพื่อให้คุณเริ่มต้นได้อย่างรวดเร็ว

ในไดเร็กทอรีตัวอย่าง เราเห็นไฟล์การกำหนดค่าสามไฟล์ที่มีคุณสมบัติโหนด - ชื่อนี้แสดงลักษณะของโหนดในรูปแบบที่กำหนด

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

SymmetricDS มีไฟล์การกำหนดค่าที่จำเป็นทั้งหมดสำหรับการออกแบบ 3 โหนดพื้นฐาน (ตัวเลือก 1) และไฟล์เดียวกันสามารถใช้สำหรับการออกแบบ 2 โหนด (ตัวเลือก 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

โหนดนี้ในการกำหนดค่า SymmetricDS เรียกว่า corp-000 และการเชื่อมต่อฐานข้อมูลได้รับการจัดการโดยไดรเวอร์ mysql jdbc ซึ่งใช้สตริงการเชื่อมต่อด้านบนและข้อมูลรับรองการเข้าสู่ระบบ เราเชื่อมต่อกับฐานข้อมูล Replica_db และตารางจะถูกสร้างขึ้นระหว่างการสร้างสคีมา sync.url แสดงตำแหน่งที่จะติดต่อโหนดเพื่อการซิงโครไนซ์

โหนด 2 บนโฮสต์ vm2 ได้รับการกำหนดค่าเป็น store-001 และส่วนที่เหลือระบุไว้ในไฟล์ node.properties ด้านล่าง Node store-001 รันฐานข้อมูล PostgreSQL และ pgdb_replica เป็นฐานข้อมูลการจำลอง 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 ที่เสร็จสมบูรณ์ประกอบด้วยพารามิเตอร์สำหรับการตั้งค่าการจำลองแบบสองทางระหว่างเซิร์ฟเวอร์ฐานข้อมูลสองแห่ง (สองโหนด) ขั้นตอนด้านล่างนี้ดำเนินการบนโฮสต์ vm1 (corp-000) ซึ่งจะสร้างสคีมาตัวอย่างที่มี 4 ตาราง จากนั้นการรัน create-sym-tables ด้วยคำสั่ง symadmin จะสร้างตารางไดเร็กทอรีที่จะจัดเก็บกฎและทิศทางของการจำลองระหว่างโหนด สุดท้าย ข้อมูลตัวอย่างจะถูกโหลดลงในตาราง

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 และ item_sale_price ได้รับการกำหนดค่าโดยอัตโนมัติเพื่อจำลองจาก corp-000 ถึง store-001 และตารางการขาย (sale_transaction และ sale_return_line_item) ได้รับการกำหนดค่าโดยอัตโนมัติเพื่อจำลองจาก store-001 ถึง corp-000 ตอนนี้เราสร้างสคีมาในฐานข้อมูล PostgreSQL บนโฮสต์ 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_) พร้อมใช้งานบนโหนด corp-000 เท่านั้น เนื่องจากเป็นที่ที่เราเรียกใช้คำสั่ง create-sym-tables และจะจัดการการจำลองแบบ และในฐานข้อมูลบน node store-001 จะมีตารางตัวอย่างเพียง 4 ตารางที่ไม่มีข้อมูล

ทั้งหมด. สภาพแวดล้อมพร้อมที่จะรันกระบวนการเซิร์ฟเวอร์ Sym บนทั้งสองโหนดดังที่แสดงด้านล่าง

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

รายการบันทึกจะถูกส่งไปยังไฟล์บันทึกพื้นหลัง (symmetric.log) ในโฟลเดอร์บันทึกในไดเร็กทอรีที่ติดตั้ง SymmetricDS รวมถึงเอาต์พุตมาตรฐาน ขณะนี้เซิร์ฟเวอร์ Sym สามารถเริ่มต้นได้ที่โหนด store-001

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

หากคุณเรียกใช้กระบวนการเซิร์ฟเวอร์ Sym บนโฮสต์ vm2 ระบบจะสร้างตารางแค็ตตาล็อก SymmetricDS ในฐานข้อมูล PostgreSQL ด้วย หากคุณรันกระบวนการเซิร์ฟเวอร์ Sym บนทั้งสองโหนด ทั้งสองโหนดจะประสานงานกันเพื่อจำลองข้อมูลจาก corp-000 ถึง store-001 หากผ่านไปไม่กี่วินาทีหากเราสอบถามทั้ง 4 ตารางจากทั้งสองด้าน เราจะเห็นว่าการจำลองแบบสำเร็จ หรือคุณสามารถส่ง bootstrap ไปที่ node store-001 จาก corp-000 ด้วยคำสั่งต่อไปนี้

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

ณ จุดนี้ บันทึกใหม่จะถูกแทรกลงในตารางรายการในฐานข้อมูล MySQL บนโหนด corp-000 (โฮสต์: vm1) และคุณสามารถตรวจสอบการจำลองแบบไปยังฐานข้อมูล PostgreSQL บน node store-001 (โฮสต์: vm2) เราเห็นการดำเนินการดึงเพื่อย้ายข้อมูลจาก 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)

ในการดำเนินการพุชเพื่อย้ายข้อมูลจาก store-001 ไปยัง corp-000 เราจะแทรกเรกคอร์ดลงในตาราง sale_transaction และตรวจสอบว่าการจำลองแบบสำเร็จ

ผล

เราเห็นความสำเร็จในการตั้งค่าการจำลองแบบสองทางของตารางตัวอย่างระหว่างฐานข้อมูล MySQL และ PostgreSQL เมื่อต้องการตั้งค่าการจำลองแบบสำหรับตารางผู้ใช้ใหม่ ให้ทำตามขั้นตอนเหล่านี้: เราสร้างตาราง t1 เป็นต้นและกำหนดค่ากฎการจำลองดังนี้ วิธีนี้เราจะกำหนดค่าเฉพาะการจำลองแบบจาก 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)

จากนั้นการกำหนดค่าจะได้รับแจ้งถึงการเปลี่ยนแปลงสคีมา นั่นคือ การเพิ่มตารางใหม่ โดยใช้คำสั่ง symadmin พร้อมด้วยอาร์กิวเมนต์ sync-triggers ซึ่งจะสร้างทริกเกอร์ขึ้นใหม่เพื่อแมปคำจำกัดความของตาราง send-schema ถูกดำเนินการเพื่อส่งการเปลี่ยนแปลงสคีมาไปยังโหนด store-001 และมีการกำหนดค่าการจำลองแบบของตาราง t1

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

ประโยชน์ของ SymmetricDS

ติดตั้งและกำหนดค่าได้ง่าย รวมถึงชุดไฟล์สำเร็จรูปพร้อมพารามิเตอร์สำหรับสร้างวงจรสามโหนดหรือสองโหนด
ฐานข้อมูลข้ามแพลตฟอร์มและความเป็นอิสระของแพลตฟอร์ม รวมถึงเซิร์ฟเวอร์ แล็ปท็อป และอุปกรณ์มือถือ
จำลองฐานข้อมูลใดๆ ไปยังฐานข้อมูลอื่นภายในเครื่อง บน WAN หรือในระบบคลาวด์
ความเป็นไปได้ในการทำงานที่เหมาะสมที่สุดกับฐานข้อมูลสองสามฐานข้อมูลหรือหลายพันฐานข้อมูลเพื่อการจำลองแบบที่สะดวก
เวอร์ชันที่ต้องชำระเงินพร้อม GUI และการสนับสนุนที่ยอดเยี่ยม

ข้อเสียของ SymmetricDS

คุณต้องกำหนดกฎและทิศทางของการจำลองด้วยตนเองบนบรรทัดคำสั่งผ่านคำสั่ง SQL เพื่อโหลดตารางแค็ตตาล็อกซึ่งอาจไม่สะดวก
การตั้งค่าตารางจำนวนมากสำหรับการจำลองแบบอาจเป็นเรื่องที่น่าเบื่อ เว้นแต่คุณจะใช้สคริปต์เพื่อสร้างคำสั่ง SQL ที่กำหนดกฎและทิศทางของการจำลองแบบ
มีการบันทึกข้อมูลมากเกินไปในบันทึก และบางครั้งคุณจำเป็นต้องจัดไฟล์บันทึกให้เป็นระเบียบเพื่อไม่ให้ใช้พื้นที่มากเกินไป

ผลลัพธ์สำหรับ SymmetricDS

SymmetricDS ช่วยให้คุณสามารถตั้งค่าการจำลองแบบสองทางระหว่างสอง สาม หรือแม้แต่หลายพันโหนดเพื่อทำซ้ำและซิงโครไนซ์ไฟล์ นี่เป็นเครื่องมือพิเศษที่ดำเนินงานหลายอย่างได้อย่างอิสระ เช่น การกู้คืนข้อมูลอัตโนมัติหลังจากการหยุดทำงานบนโหนดเป็นเวลานาน การแลกเปลี่ยนข้อมูลที่ปลอดภัยและมีประสิทธิภาพระหว่างโหนดผ่าน HTTPS การจัดการข้อขัดแย้งอัตโนมัติตามกฎชุดต่างๆ เป็นต้น SymmetricDS ดำเนินการ การจำลองแบบระหว่างฐานข้อมูลใดๆ ดังนั้นจึงสามารถใช้งานได้หลากหลายสถานการณ์ รวมถึงการย้าย การโยกย้าย การกระจาย การกรอง และการเปลี่ยนแปลงข้อมูลข้ามแพลตฟอร์ม

ตัวอย่างจะขึ้นอยู่กับอย่างเป็นทางการ คำแนะนำฉบับย่อ โดย SymmetricDS ใน คู่มือการใช้ อธิบายรายละเอียดเกี่ยวกับแนวคิดต่างๆ ที่เกี่ยวข้องกับการตั้งค่าการจำลองด้วย SymmetricDS

ที่มา: will.com