ការចម្លងឆ្លងរវាង PostgreSQL និង MySQL

ខ្ញុំនឹងគូសបញ្ជាក់ការចម្លងឆ្លងរវាង PostgreSQL និង MySQL ក៏ដូចជាវិធីសាស្រ្តសម្រាប់ដំឡើងការចម្លងឆ្លងរវាងម៉ាស៊ីនមេមូលដ្ឋានទិន្នន័យទាំងពីរ។ ជាធម្មតា មូលដ្ឋានទិន្នន័យចម្លងឆ្លងត្រូវបានគេហៅថាដូចគ្នា ហើយវាជាវិធីសាស្ត្រងាយស្រួលក្នុងការផ្លាស់ប្តូរពីម៉ាស៊ីនមេ RDBMS មួយទៅម៉ាស៊ីនមេមួយទៀត។

មូលដ្ឋានទិន្នន័យ PostgreSQL និង MySQL ជាទូទៅត្រូវបានចាត់ទុកថាជាទំនាក់ទំនង ប៉ុន្តែជាមួយនឹងផ្នែកបន្ថែមបន្ថែម ពួកគេផ្តល់នូវសមត្ថភាព NoSQL ។ នៅទីនេះយើងនឹងពិភាក្សាអំពីការចម្លងរវាង PostgreSQL និង MySQL តាមទស្សនៈ DBMS ដែលទាក់ទង។

យើងនឹងមិនពិពណ៌នាអំពីការងារខាងក្នុងទាំងមូលទេ គ្រាន់តែជាគោលការណ៍ជាមូលដ្ឋាន ដើម្បីអោយអ្នកទទួលបានគំនិតនៃការកំណត់រចនាសម្ព័ន្ធការចម្លងរវាងម៉ាស៊ីនមេមូលដ្ឋានទិន្នន័យ គុណសម្បត្តិ ដែនកំណត់ និងករណីប្រើប្រាស់។

ជាធម្មតា ការចម្លងរវាងម៉ាស៊ីនមេមូលដ្ឋានទិន្នន័យដូចគ្នាបេះបិទពីរគឺធ្វើឡើងក្នុងទម្រង់គោលពីរ ឬប្រើសំណួររវាងមេ (អ្នកបោះពុម្ពផ្សាយ មេ ឬសកម្ម) និងទាសករ (អ្នកជាវ រង់ចាំ ឬអកម្ម)។ គោលបំណងនៃការចម្លងគឺដើម្បីផ្តល់នូវច្បាប់ចម្លងពេលវេលាពិតប្រាកដនៃមូលដ្ឋានទិន្នន័យមេនៅលើផ្នែកទាសករ។ ក្នុងករណីនេះ ទិន្នន័យត្រូវបានផ្ទេរពីមេទៅ slave ពោលគឺពីសកម្មទៅអកម្ម ពីព្រោះការចម្លងត្រូវបានអនុវត្តក្នុងទិសដៅតែមួយប៉ុណ្ណោះ។ ប៉ុន្តែអ្នកអាចរៀបចំការចម្លងរវាងមូលដ្ឋានទិន្នន័យពីរក្នុងទិសដៅទាំងពីរ ដូច្នេះទិន្នន័យត្រូវបានផ្ទេរពី slave ទៅមេនៅក្នុងការកំណត់រចនាសម្ព័ន្ធសកម្ម។ អ្វីៗទាំងអស់នេះ រួមទាំងការចម្លងតាមលំហ គឺអាចធ្វើទៅបានរវាងម៉ាស៊ីនមេមូលដ្ឋានទិន្នន័យដូចគ្នាបេះបិទពីរ ឬច្រើន។ ការកំណត់រចនាសម្ព័ន្ធសកម្ម ឬសកម្ម-អកម្មអាស្រ័យលើតម្រូវការ ភាពអាចរកបាននៃសមត្ថភាពបែបនេះក្នុងការកំណត់រចនាសម្ព័ន្ធដំបូង ឬការប្រើប្រាស់ដំណោះស្រាយការកំណត់រចនាសម្ព័ន្ធខាងក្រៅ និងការដោះដូរដែលមានស្រាប់។

ការកំណត់រចនាសម្ព័ន្ធដែលបានពិពណ៌នាគឺអាចធ្វើទៅបានរវាងម៉ាស៊ីនមេមូលដ្ឋានទិន្នន័យផ្សេងគ្នា។ ម៉ាស៊ីនមេអាចត្រូវបានកំណត់រចនាសម្ព័ន្ធដើម្បីទទួលយកទិន្នន័យចម្លងពីម៉ាស៊ីនមេមូលដ្ឋានទិន្នន័យផ្សេងទៀត ហើយនៅតែរក្សាការថតចម្លងទិន្នន័យដែលបានចម្លងតាមពេលវេលាជាក់ស្តែង។ MySQL និង PostgreSQL ផ្តល់ជូននូវការកំណត់រចនាសម្ព័ន្ធទាំងនេះភាគច្រើននៅក្នុងផ្ទះ ឬតាមរយៈផ្នែកបន្ថែមភាគីទីបី រួមទាំងវិធីសាស្ត្រកំណត់ហេតុគោលពីរ ការចាក់សោថាស និងសេចក្តីថ្លែងការណ៍ និងវិធីសាស្ត្រផ្អែកលើជួរដេក។

ការចម្លងឆ្លងគ្នារវាង MySQL និង PostgreSQL គឺចាំបាច់សម្រាប់ការធ្វើចំណាកស្រុកមួយដងពីម៉ាស៊ីនមេមូលដ្ឋានទិន្នន័យមួយទៅម៉ាស៊ីនមេមួយទៀត។ មូលដ្ឋានទិន្នន័យទាំងនេះប្រើពិធីការផ្សេងគ្នា ដូច្នេះវាមិនអាចធ្វើទៅបានដើម្បីភ្ជាប់ពួកវាដោយផ្ទាល់ទេ។ ដើម្បីបង្កើតការផ្លាស់ប្តូរទិន្នន័យ អ្នកអាចប្រើឧបករណ៍ប្រភពបើកចំហខាងក្រៅ ឧទាហរណ៍ pg_chameleon ។

តើអ្វីទៅជា pg_chameleon

pg_chameleon គឺជាប្រព័ន្ធចម្លងពី MySQL ទៅ PostgreSQL នៅក្នុង Python 3. វាប្រើ open source mysql-replication library ក៏មាននៅក្នុង Python ផងដែរ។ រូបភាពជួរត្រូវបានស្រង់ចេញពីតារាង MySQL និងរក្សាទុកជាវត្ថុ JSONB នៅក្នុងមូលដ្ឋានទិន្នន័យ PostgreSQL ហើយបន្ទាប់មកត្រូវបានឌិគ្រីបដោយមុខងារ pl/pgsql និងផលិតឡើងវិញនៅក្នុងមូលដ្ឋានទិន្នន័យ PostgreSQL ។

លក្ខណៈពិសេសនៃ pg_chameleon

គ្រោងការណ៍ MySQL ច្រើនពីចង្កោមតែមួយអាចត្រូវបានចម្លងទៅមូលដ្ឋានទិន្នន័យ PostgreSQL គោលដៅតែមួយនៅក្នុងការកំណត់រចនាសម្ព័ន្ធមួយទៅច្រើន
ឈ្មោះគ្រោងការណ៍ប្រភព និងគោលដៅមិនអាចដូចគ្នាបានទេ។
ទិន្នន័យ​ចម្លង​អាច​ត្រូវ​បាន​ទៅ​យក​ពី​ការ​ចម្លង MySQL ល្បាក់។
តារាងដែលមិនអាចចម្លង ឬបង្កើតកំហុសត្រូវបានដកចេញ។
មុខងារចម្លងនីមួយៗត្រូវបានគ្រប់គ្រងដោយដេមិន។
គ្រប់គ្រងតាមរយៈប៉ារ៉ាម៉ែត្រដែលមានមូលដ្ឋានលើ YAML និងឯកសារកំណត់រចនាសម្ព័ន្ធ។

ឧទាហរណ៍:

ម៉ាស៊ីន
vm៣២៥២
vm៣២៥២

កំណែប្រព័ន្ធប្រតិបត្តិការ
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64

កំណែម៉ាស៊ីនមេ DB
កម្មវិធី MySQL 5.7.26
PostgreSQL ៨.៤.៦

ច្រក DB
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 ។

លទ្ធផល។

ដូចដែលយើងបាននិយាយរួចមកហើយ មុខងារចម្លងនីមួយៗត្រូវបានគ្រប់គ្រងដោយដេមិន។ ដើម្បីមើលពួកវា យើងសួរតារាងដំណើរការដោយប្រើពាក្យបញ្ជា Linux ps ដូចបានបង្ហាញខាងក្រោម។

លទ្ធផល។

ការចម្លងមិនត្រូវបានចាត់ទុកថាកំណត់រចនាសម្ព័ន្ធទេ រហូតទាល់តែយើងសាកល្បងវាក្នុងពេលជាក់ស្តែង ដូចបានបង្ហាញខាងក្រោម។ យើងបង្កើតតារាងមួយ បញ្ចូលកំណត់ត្រាពីរបីទៅក្នុងមូលដ្ឋានទិន្នន័យ MySQL ហើយហៅអាគុយម៉ង់ sync_tables ក្នុង pg_chameleon ដើម្បីធ្វើបច្ចុប្បន្នភាពដេមិន និងចម្លងតារាងជាមួយកំណត់ត្រាទៅមូលដ្ឋានទិន្នន័យ 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 និង Pull ដោយផ្អែកលើសំណុំនៃច្បាប់។
ការផ្ទេរទិន្នន័យអាចធ្វើទៅបានតាមរយៈបណ្តាញសុវត្ថិភាព និងកម្រិតបញ្ជូនទាប។
ការងើបឡើងវិញដោយស្វ័យប្រវត្តិនៅពេលដែលថ្នាំងបន្តប្រតិបត្តិការបន្ទាប់ពីការបរាជ័យ និងការដោះស្រាយជម្លោះដោយស្វ័យប្រវត្តិ។
Cloud ដែលត្រូវគ្នា និង APIs ផ្នែកបន្ថែមដ៏មានឥទ្ធិពល។

ឧទាហរណ៍:

SymmetricDS អាចត្រូវបានកំណត់រចនាសម្ព័ន្ធក្នុងជម្រើសមួយក្នុងចំណោមជម្រើសពីរ៖
ថ្នាំងមេ (មេ) ដែលសម្របសម្រួលការចម្លងទិន្នន័យជាកណ្តាលរវាងថ្នាំង slave (កូន) ពីរ ហើយការទំនាក់ទំនងរវាងថ្នាំងកូនកើតឡើងតាមរយៈមេប៉ុណ្ណោះ។
ថ្នាំងសកម្ម (ថ្នាំង 1) អាចទំនាក់ទំនងសម្រាប់ការចម្លងជាមួយថ្នាំងសកម្មផ្សេងទៀត (ថ្នាំង 2) ដោយគ្មានអន្តរការី។

នៅក្នុងជម្រើសទាំងពីរ ការផ្លាស់ប្តូរទិន្នន័យកើតឡើងដោយប្រើ Push និង Pull ។ ក្នុងឧទាហរណ៍នេះ យើងនឹងពិចារណាការកំណត់រចនាសម្ព័ន្ធសកម្ម-សកម្ម។ វានឹងចំណាយពេលយូរពេកក្នុងការពិពណ៌នាអំពីស្ថាបត្យកម្មទាំងមូល ដូច្នេះធ្វើការស្រាវជ្រាវរបស់អ្នក។ ភាពជាអ្នកដឹកនាំដើម្បីស្វែងយល់បន្ថែមអំពីឧបករណ៍ SymmetricDS ។

ការដំឡើង SymmetricDS គឺសាមញ្ញណាស់៖ ទាញយកកំណែប្រភពបើកចំហនៃឯកសារ zip ពីទីនេះ ហើយយកវាចេញគ្រប់ទីកន្លែងដែលអ្នកចង់បាន។ តារាងខាងក្រោមផ្តល់ព័ត៌មានអំពីទីតាំងដំឡើង និងកំណែរបស់ SymmetricDS ក្នុងឧទាហរណ៍នេះ ក៏ដូចជាកំណែមូលដ្ឋានទិន្នន័យ កំណែលីនុច អាសយដ្ឋាន IP និងច្រកសម្រាប់ថ្នាំងទាំងពីរ។

ម៉ាស៊ីន
vm៣២៥២
vm៣២៥២

កំណែប្រព័ន្ធប្រតិបត្តិការ
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64

កំណែម៉ាស៊ីនមេ DB
កម្មវិធី MySQL 5.7.26
PostgreSQL ៨.៤.៦

ច្រក 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
Corp-000
ហាង-001

នៅទីនេះយើងដំឡើង SymmetricDS នៅក្នុង /usr/local/symmetric-server-3.9.20 ហើយថតរង និងឯកសារផ្សេងៗនឹងត្រូវបានរក្សាទុកនៅទីនោះ។ យើងចាប់អារម្មណ៍លើថតរងគំរូ និងម៉ាស៊ីន។ ថតគំរូមានឯកសារកំណត់រចនាសម្ព័ន្ធឧទាហរណ៍ជាមួយនឹងលក្ខណៈសម្បត្តិថ្នាំង ក៏ដូចជាឧទាហរណ៍ស្គ្រីប SQL ដើម្បីឱ្យអ្នកចាប់ផ្តើមយ៉ាងឆាប់រហ័ស។

នៅក្នុងថតសំណាកគំរូ យើងឃើញឯកសារកំណត់រចនាសម្ព័ន្ធចំនួនបីដែលមានលក្ខណៈសម្បត្តិថ្នាំង - ឈ្មោះបង្ហាញលក្ខណៈរបស់ថ្នាំងនៅក្នុងគ្រោងការណ៍ជាក់លាក់មួយ។

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

ថ្នាំងនេះនៅក្នុងការកំណត់រចនាសម្ព័ន្ធ SymmetricDS ត្រូវបានគេហៅថា corp-000 ហើយការភ្ជាប់មូលដ្ឋានទិន្នន័យត្រូវបានគ្រប់គ្រងដោយកម្មវិធីបញ្ជា mysql jdbc ដែលប្រើខ្សែភ្ជាប់ខាងលើ និងព័ត៌មានបញ្ជាក់ការចូល។ យើងភ្ជាប់ទៅមូលដ្ឋានទិន្នន័យ replica_db ហើយតារាងនឹងត្រូវបានបង្កើតកំឡុងពេលបង្កើតគ្រោងការណ៍។ sync.url បង្ហាញកន្លែងដែលត្រូវទាក់ទងថ្នាំងសម្រាប់ការធ្វើសមកាលកម្ម។

ថ្នាំង 2 នៅលើម៉ាស៊ីន vm2 ត្រូវបានកំណត់រចនាសម្ព័ន្ធជា store-001 ហើយនៅសល់ត្រូវបានបញ្ជាក់នៅក្នុងឯកសារ node.properties ខាងក្រោម។ Node store-001 ដំណើរការមូលដ្ឋានទិន្នន័យ PostgreSQL ហើយ pgdb_replica គឺជាមូលដ្ឋានទិន្នន័យចម្លង។ register.url អនុញ្ញាតឱ្យ host vm2 ទាក់ទង host 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) ដែលនឹងបង្កើតគ្រោងការណ៍ឧទាហរណ៍ជាមួយតារាង 4 ។ បន្ទាប់មកការដំណើរការ create-sym-tables ជាមួយនឹងពាក្យបញ្ជា symadmin បង្កើតតារាង directory ដែលច្បាប់ និងទិសដៅនៃការចម្លងរវាង 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 ត្រូវបានកំណត់រចនាសម្ព័ន្ធដោយស្វ័យប្រវត្តិដើម្បីចម្លងពី 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_) បច្ចុប្បន្នមាននៅលើ node 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 server អាចត្រូវបានផ្តួចផ្តើមនៅលើ node 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 នៅលើ node corp-000 (host: vm1) ហើយអ្នកអាចពិនិត្យមើលការចម្លងរបស់វាទៅមូលដ្ឋានទិន្នន័យ PostgreSQL នៅលើ node store-001 (host: 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)

ដើម្បីអនុវត្តប្រតិបត្តិការ Push ដើម្បីផ្លាស់ទីទិន្នន័យពី 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 ដែលបង្កើត triggers ឡើងវិញ ដើម្បីគូសផែនទីនិយមន័យតារាង។ send-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

ការដំឡើង និងការកំណត់ងាយស្រួល រួមទាំងសំណុំឯកសារដែលត្រៀមរួចជាស្រេចដែលមានប៉ារ៉ាម៉ែត្រសម្រាប់បង្កើតសៀគ្វីបីថ្នាំង ឬពីរថ្នាំង។
មូលដ្ឋានទិន្នន័យឆ្លងវេទិកា និងឯករាជ្យនៃវេទិកា រួមទាំងម៉ាស៊ីនមេ កុំព្យូទ័រយួរដៃ និងឧបករណ៍ចល័ត។
ចម្លងមូលដ្ឋានទិន្នន័យណាមួយទៅមូលដ្ឋានទិន្នន័យផ្សេងទៀតនៅក្នុងមូលដ្ឋាននៅលើ WAN ឬក្នុងពពក។
លទ្ធភាពនៃការងារដ៏ល្អប្រសើរជាមួយនឹងមូលដ្ឋានទិន្នន័យពីរបី ឬរាប់ពាន់សម្រាប់ការចម្លងងាយស្រួល។
កំណែបង់ប្រាក់ជាមួយ GUI និងការគាំទ្រដ៏ល្អ។

គុណវិបត្តិនៃ SymmetricDS

អ្នកត្រូវកំណត់ច្បាប់ និងទិសដៅនៃការចម្លងដោយដៃនៅលើបន្ទាត់ពាក្យបញ្ជាតាមរយៈសេចក្តីថ្លែងការណ៍ SQL ដើម្បីផ្ទុកតារាងកាតាឡុក ដែលអាចមានការរអាក់រអួល។
ការដំឡើងតារាងជាច្រើនសម្រាប់ការចម្លងអាចធុញទ្រាន់ លុះត្រាតែអ្នកប្រើស្គ្រីបដើម្បីបង្កើតសេចក្តីថ្លែងការណ៍ SQL ដែលកំណត់ច្បាប់ និងទិសដៅនៃការចម្លង។
មានព័ត៌មានច្រើនពេកដែលត្រូវបានកត់ត្រានៅក្នុងកំណត់ហេតុ ហើយពេលខ្លះអ្នកត្រូវរៀបចំឯកសារកំណត់ហេតុដើម្បីកុំឱ្យវាយកកន្លែងច្រើនពេក។

លទ្ធផលសម្រាប់ SymmetricDS

SymmetricDS អនុញ្ញាតឱ្យអ្នករៀបចំការចម្លងពីរផ្លូវរវាងថ្នាំងពីរ បី ឬសូម្បីតែរាប់ពាន់ថ្នាំងដើម្បីចម្លង និងធ្វើសមកាលកម្មឯកសារ។ នេះគឺជាឧបករណ៍ពិសេសមួយដែលអនុវត្តដោយឯករាជ្យនូវកិច្ចការជាច្រើន ដូចជាការសង្គ្រោះទិន្នន័យដោយស្វ័យប្រវត្តិបន្ទាប់ពីរយៈពេលរង់ចាំយូរនៅលើថ្នាំង ការផ្លាស់ប្តូរទិន្នន័យប្រកបដោយសុវត្ថិភាព និងប្រសិទ្ធភាពរវាងថ្នាំងតាមរយៈ HTTPS ការគ្រប់គ្រងជម្លោះដោយស្វ័យប្រវត្តិដោយផ្អែកលើសំណុំនៃច្បាប់។ល។ SymmetricDS ដំណើរការ ការចម្លងរវាងមូលដ្ឋានទិន្នន័យណាមួយ ដូច្នេះហើយ វាអាចត្រូវបានប្រើសម្រាប់សេណារីយ៉ូជាច្រើន រួមទាំងការធ្វើចំណាកស្រុក ការធ្វើចំណាកស្រុក ការចែកចាយ ការត្រង និងការបំប្លែងទិន្នន័យនៅលើវេទិកានានា។

ឧទាហរណ៍គឺផ្អែកលើមន្ត្រី ការណែនាំរហ័ស ដោយ SymmetricDS ។ IN សៀវភៅណែនាំអ្នកប្រើប្រាស់ ពិពណ៌នាលម្អិតអំពីគោលគំនិតផ្សេងៗដែលពាក់ព័ន្ធនឹងការបង្កើតការចម្លងជាមួយ SymmetricDS ។

ប្រភព: www.habr.com