PostgreSQL, MySQL എന്നിവയ്ക്കിടയിലുള്ള ക്രോസ് റെപ്ലിക്കേഷൻ

PostgreSQL, MySQL എന്നിവയ്ക്കിടയിലുള്ള ക്രോസ്-റെപ്ലിക്കേഷന്റെ രൂപരേഖയും രണ്ട് ഡാറ്റാബേസ് സെർവറുകൾക്കിടയിൽ ക്രോസ്-റെപ്ലിക്കേഷൻ സജ്ജീകരിക്കുന്നതിനുള്ള രീതികളും ഞാൻ വിവരിക്കും. സാധാരണഗതിയിൽ, ക്രോസ്-റെപ്ലിക്കേറ്റഡ് ഡാറ്റാബേസുകളെ ഹോമോജീനിയസ് എന്ന് വിളിക്കുന്നു, ഇത് ഒരു RDBMS സെർവറിൽ നിന്ന് മറ്റൊന്നിലേക്ക് മാറുന്നതിനുള്ള സൗകര്യപ്രദമായ രീതിയാണ്.

PostgreSQL, MySQL ഡാറ്റാബേസുകൾ സാധാരണയായി റിലേഷണൽ ആയി കണക്കാക്കപ്പെടുന്നു, എന്നാൽ അധിക വിപുലീകരണങ്ങളോടൊപ്പം അവ NoSQL കഴിവുകൾ വാഗ്ദാനം ചെയ്യുന്നു. ഒരു റിലേഷണൽ ഡിബിഎംഎസ് വീക്ഷണകോണിൽ നിന്ന് PostgreSQL ഉം MySQL ഉം തമ്മിലുള്ള പകർപ്പ് ഞങ്ങൾ ഇവിടെ ചർച്ച ചെയ്യും.

ഡാറ്റാബേസ് സെർവറുകൾ, ഗുണങ്ങൾ, പരിമിതികൾ, ഉപയോഗ കേസുകൾ എന്നിവയ്‌ക്കിടയിലുള്ള പകർപ്പ് ക്രമീകരിക്കുന്നതിനെക്കുറിച്ചുള്ള ഒരു ആശയം നിങ്ങൾക്ക് ലഭിക്കുന്നതിന് അടിസ്ഥാന തത്വങ്ങൾ മാത്രമുള്ള മുഴുവൻ ആന്തരിക പ്രവർത്തനങ്ങളെയും ഞങ്ങൾ വിവരിക്കില്ല.

സാധാരണഗതിയിൽ, സമാനമായ രണ്ട് ഡാറ്റാബേസ് സെർവറുകൾ തമ്മിലുള്ള പകർപ്പ് ബൈനറി മോഡിൽ അല്ലെങ്കിൽ ഒരു മാസ്റ്ററും (അതായത് പ്രസാധകൻ, മാസ്റ്റർ അല്ലെങ്കിൽ സജീവം) ഒരു സ്ലേവ് (സബ്‌സ്‌ക്രൈബർ, സ്റ്റാൻഡ്‌ബൈ അല്ലെങ്കിൽ നിഷ്‌ക്രിയം) എന്നിവയ്‌ക്കിടയിലുള്ള അന്വേഷണങ്ങൾ ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്. സ്ലേവ് സൈഡിൽ മാസ്റ്റർ ഡാറ്റാബേസിന്റെ തത്സമയ പകർപ്പ് നൽകുക എന്നതാണ് റെപ്ലിക്കേഷന്റെ ഉദ്ദേശ്യം. ഈ സാഹചര്യത്തിൽ, ഡാറ്റ മാസ്റ്ററിൽ നിന്ന് സ്ലേവിലേക്ക് കൈമാറുന്നു, അതായത്, സജീവത്തിൽ നിന്ന് നിഷ്ക്രിയതയിലേക്ക്, കാരണം ഒരു ദിശയിൽ മാത്രമേ പകർത്തൽ നടത്തൂ. എന്നാൽ നിങ്ങൾക്ക് രണ്ട് ദിശകളിലുമുള്ള രണ്ട് ഡാറ്റാബേസുകൾക്കിടയിൽ തനിപ്പകർപ്പ് സജ്ജീകരിക്കാൻ കഴിയും, അതുവഴി ഡാറ്റ സ്ലേവിൽ നിന്ന് മാസ്റ്ററിലേക്ക് ഒരു സജീവ-സജീവ കോൺഫിഗറേഷനിൽ കൈമാറ്റം ചെയ്യപ്പെടും. രണ്ടോ അതിലധികമോ സമാനമായ ഡാറ്റാബേസ് സെർവറുകൾക്കിടയിൽ കാസ്‌കേഡിംഗ് റെപ്ലിക്കേഷൻ ഉൾപ്പെടെയുള്ള ഇവയെല്ലാം സാധ്യമാണ്.ആക്റ്റീവ്-ആക്റ്റീവ് അല്ലെങ്കിൽ ആക്റ്റീവ്-പാസീവ് കോൺഫിഗറേഷൻ, പ്രാരംഭ കോൺഫിഗറേഷനിലോ ബാഹ്യ കോൺഫിഗറേഷൻ സൊല്യൂഷനുകളുടെയും നിലവിലുള്ള ട്രേഡ്-ഓഫുകളുടെയും അത്തരം കഴിവുകളുടെ ആവശ്യകത, ലഭ്യത എന്നിവയെ ആശ്രയിച്ചിരിക്കുന്നു.

വ്യത്യസ്ത ഡാറ്റാബേസ് സെർവറുകൾക്കിടയിൽ വിവരിച്ച കോൺഫിഗറേഷൻ സാധ്യമാണ്. മറ്റൊരു ഡാറ്റാബേസ് സെർവറിൽ നിന്ന് പകർത്തിയ ഡാറ്റ സ്വീകരിക്കുന്നതിനും അതേ സമയം പകർത്തിയ ഡാറ്റയുടെ തത്സമയ സ്നാപ്പ്ഷോട്ടുകൾ നിലനിർത്തുന്നതിനും സെർവറിനെ കോൺഫിഗർ ചെയ്യാനാകും. MySQL, PostgreSQL എന്നിവ ഈ കോൺഫിഗറേഷനുകളിൽ ഭൂരിഭാഗവും ഇൻ-ഹൗസ് അല്ലെങ്കിൽ മൂന്നാം കക്ഷി എക്സ്റ്റൻഷനുകൾ വഴി വാഗ്ദാനം ചെയ്യുന്നു, ബൈനറി ലോഗ് രീതികൾ, ഡിസ്ക് ലോക്കിംഗ്, സ്റ്റേറ്റ്മെന്റ്, റോ-അടിസ്ഥാന രീതികൾ എന്നിവയുൾപ്പെടെ.

ഒരു ഡാറ്റാബേസ് സെർവറിൽ നിന്ന് മറ്റൊന്നിലേക്ക് ഒറ്റത്തവണ മൈഗ്രേഷനായി MySQL-നും PostgreSQL-നും ഇടയിലുള്ള ക്രോസ് റെപ്ലിക്കേഷൻ ആവശ്യമാണ്. ഈ ഡാറ്റാബേസുകൾ വ്യത്യസ്ത പ്രോട്ടോക്കോളുകൾ ഉപയോഗിക്കുന്നു, അതിനാൽ അവയെ നേരിട്ട് ലിങ്കുചെയ്യാൻ സാധ്യമല്ല. ഡാറ്റാ എക്സ്ചേഞ്ച് സ്ഥാപിക്കുന്നതിന്, നിങ്ങൾക്ക് ഒരു ബാഹ്യ ഓപ്പൺ സോഴ്സ് ടൂൾ ഉപയോഗിക്കാം, ഉദാഹരണത്തിന് pg_chameleon.

എന്താണ് pg_chameleon

പൈത്തൺ 3-ലെ MySQL-ൽ നിന്ന് PostgreSQL-ലേക്കുള്ള ഒരു റെപ്ലിക്കേഷൻ സിസ്റ്റമാണ് pg_chameleon. ഇത് പൈത്തണിലും ഓപ്പൺ സോഴ്സ് mysql-replication ലൈബ്രറി ഉപയോഗിക്കുന്നു. വരി ചിത്രങ്ങൾ MySQL പട്ടികകളിൽ നിന്ന് എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത് PostgreSQL ഡാറ്റാബേസിൽ JSONB ഒബ്‌ജക്റ്റുകളായി സംഭരിക്കുകയും തുടർന്ന് pl/pgsql ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ഡീക്രിപ്റ്റ് ചെയ്യുകയും PostgreSQL ഡാറ്റാബേസിൽ പുനർനിർമ്മിക്കുകയും ചെയ്യുന്നു.

pg_chameleon-ന്റെ സവിശേഷതകൾ

ഒരേ ക്ലസ്റ്ററിൽ നിന്നുള്ള ഒന്നിലധികം MySQL സ്കീമകൾ ഒന്നിൽ നിന്ന് നിരവധി കോൺഫിഗറേഷനിൽ ഒരൊറ്റ ടാർഗെറ്റ് PostgreSQL ഡാറ്റാബേസിലേക്ക് പകർത്താനാകും.
ഉറവിടവും ടാർഗെറ്റ് സ്കീമ നാമങ്ങളും ഒരുപോലെ ആയിരിക്കരുത്.
ഒരു കാസ്‌കേഡ് ചെയ്ത MySQL പകർപ്പിൽ നിന്ന് റെപ്ലിക്കേഷൻ ഡാറ്റ വീണ്ടെടുക്കാൻ കഴിയും.
പിശകുകൾ ആവർത്തിക്കാനോ സൃഷ്ടിക്കാനോ കഴിയാത്ത പട്ടികകൾ ഒഴിവാക്കിയിരിക്കുന്നു.
ഓരോ അനുകരണ പ്രവർത്തനവും ഡെമണുകളാൽ നിയന്ത്രിക്കപ്പെടുന്നു.
YAML അടിസ്ഥാനമാക്കിയുള്ള പാരാമീറ്ററുകളും കോൺഫിഗറേഷൻ ഫയലുകളും വഴി നിയന്ത്രിക്കുക.

ഉദാഹരണം:

ഹോസ്റ്റ്
vm1
vm2

OS പതിപ്പ്
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64

ഡിബി സെർവർ പതിപ്പ്
MySQL 5.7.26
PostgreSQL 10.5

ഡിബി പോർട്ട്
3306
5433

IP വിലാസം
192.168.56.102
192.168.56.106

ആരംഭിക്കുന്നതിന്, pg_chameleon ഇൻസ്റ്റാൾ ചെയ്യാൻ ആവശ്യമായ എല്ലാ ഘടകങ്ങളും തയ്യാറാക്കുക. ഈ ഉദാഹരണം പൈത്തൺ 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 വിജയകരമായി ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, ഒരു വെർച്വൽ എൻവയോൺമെന്റ് സൃഷ്ടിക്കുന്നതും സജീവമാക്കുന്നതും പോലെയുള്ള ശേഷിക്കുന്ന ആവശ്യകതകൾ നിങ്ങൾ പൂർത്തിയാക്കേണ്ടതുണ്ട്. കൂടാതെ, പിപ്പ് മൊഡ്യൂൾ ഏറ്റവും പുതിയ പതിപ്പിലേക്ക് അപ്ഡേറ്റ് ചെയ്യുകയും pg_chameleon ഇൻസ്റ്റാൾ ചെയ്യാൻ ഉപയോഗിക്കുകയും ചെയ്യുന്നു. ഏറ്റവും പുതിയ പതിപ്പ് 2.0.9 ആണെങ്കിലും ചുവടെയുള്ള കമാൻഡുകൾ മനഃപൂർവ്വം pg_chameleon 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 പ്രവർത്തനക്ഷമമാക്കുന്നതിനും സ്ഥിരസ്ഥിതി ഡയറക്ടറികളും കോൺഫിഗറേഷൻ ഫയലുകളും സൃഷ്ടിക്കുന്നതിനും 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-ൽ MySQL കമ്മ്യൂണിറ്റി ഉദാഹരണങ്ങളായി നൽകുന്ന വരികളുള്ള 4 പട്ടികകൾ അടങ്ങിയിരിക്കുന്നു. ഇത് ഡൗൺലോഡ് ചെയ്യാം ഇവിടെ. വരികൾ സൃഷ്‌ടിക്കുന്നതിനും ഇറക്കുമതി ചെയ്യുന്നതിനുമുള്ള നിർദ്ദേശങ്ങളോടുകൂടിയ ടാർ, കംപ്രസ് ചെയ്‌ത ആർക്കൈവ് ആയാണ് സാമ്പിൾ ഡാറ്റാബേസ് വരുന്നത്.

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 വശത്ത്, MySQL ഡാറ്റാബേസിൽ നിന്നുള്ള മാറ്റങ്ങൾ സ്വീകരിക്കുന്ന ഒരു db_replica ഡാറ്റാബേസ് സൃഷ്ടിച്ചിരിക്കുന്നു. PostgreSQL-ലെ usr_replica എന്ന ഉപയോക്താവ് 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) കമാൻഡുകൾ പരിസ്ഥിതി തയ്യാറാക്കുകയും ഉറവിടം ചേർക്കുകയും പകർപ്പ് ആരംഭിക്കുകയും ചെയ്യുന്നു. pg_chameleon-ലേക്കുള്ള create_replica_schema ആർഗ്യുമെന്റ് പോസ്റ്റ്‌ഗ്രെഎസ്‌ക്യുഎൽ ഡാറ്റാബേസിൽ ഒരു ഡിഫോൾട്ട് സ്‌കീമയും (sch_chameleon) ഒരു റെപ്ലിക്കേഷൻ സ്കീമയും (pgworld_x) സൃഷ്ടിക്കുന്നു, ഞങ്ങൾ ഇതിനകം ചർച്ച ചെയ്തതുപോലെ. കോൺഫിഗറേഷൻ ഫയൽ (default.yml) വായിച്ചുകൊണ്ട് add_source ആർഗ്യുമെന്റ് കോൺഫിഗറേഷനിലേക്ക് ഒരു സോഴ്സ് ഡാറ്റാബേസ് ചേർക്കുന്നു, ഞങ്ങളുടെ കാര്യത്തിൽ ഇത് 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 ഡാറ്റാബേസിലേക്ക് രണ്ട് റെക്കോർഡുകൾ ചേർക്കുകയും ഡെമണുകൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനും PostgreSQL ഡാറ്റാബേസിലേക്ക് റെക്കോർഡുകൾ ഉപയോഗിച്ച് പട്ടിക പകർത്തുന്നതിനും pg_chameleon-ലെ sync_tables ആർഗ്യുമെന്റിലേക്ക് വിളിക്കുന്നു.

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 കമാൻഡുകൾ അതിന്റെ അവസാനമായിരിക്കും. എല്ലാ ടാർഗെറ്റ് ടേബിളുകളുടെയും വരികൾ പകർത്തിയെന്ന് ഞങ്ങൾക്ക് ഉറപ്പുണ്ടായതിന് ശേഷം കമാൻഡുകൾ എക്‌സിക്യൂട്ട് ചെയ്യേണ്ടതുണ്ട്, കൂടാതെ ഉറവിട ഡാറ്റാബേസിനോ റെപ്ലിക്കേഷൻ സ്കീമിലേക്കോ (sch_chameleon) റഫറൻസുകളില്ലാതെ വൃത്തിയായി മൈഗ്രേറ്റ് ചെയ്ത PostgreSQL ഡാറ്റാബേസ് ആയിരിക്കും ഫലം.

$> 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-ന്റെ ഫലങ്ങൾ

MySQL-ൽ നിന്ന് PostgreSQL-ലേക്ക് ഒരു ഡാറ്റാബേസ് മൈഗ്രേറ്റ് ചെയ്യുന്നതിന് pg_chameleon-ലെ റെപ്ലിക്കേഷൻ രീതി മികച്ചതാണ്. റിപ്ലിക്കേഷൻ ഒരു വഴി മാത്രമാണെന്നതാണ് പ്രധാന പോരായ്മ, അതിനാൽ ഡാറ്റാബേസ് പ്രൊഫഷണലുകൾ മൈഗ്രേഷനല്ലാതെ മറ്റെന്തെങ്കിലും ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നില്ല. എന്നാൽ വൺ-വേ റിപ്ലിക്കേഷന്റെ പ്രശ്നം മറ്റൊരു ഓപ്പൺ സോഴ്സ് ടൂൾ ഉപയോഗിച്ച് പരിഹരിക്കാൻ കഴിയും - സിമെട്രിക്ഡിഎസ്.

ഔദ്യോഗിക ഡോക്യുമെന്റേഷനിൽ കൂടുതൽ വായിക്കുക ഇവിടെ. കമാൻഡ് ലൈൻ സഹായം കണ്ടെത്താനാകും ഇവിടെ.

SymmetricDS ന്റെ അവലോകനം

ഏത് ഡാറ്റാബേസും മറ്റേതെങ്കിലും സാധാരണ ഡാറ്റാബേസിലേക്ക് പകർത്തുന്ന ഒരു ഓപ്പൺ സോഴ്‌സ് ടൂളാണ് SymmetricDS: Oracle, MongoDB, PostgreSQL, MySQL, SQL Server, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird, മറ്റ് ക്ലൗഡ് ഡാറ്റാബേസ് സംഭവങ്ങൾ, ഉദാ. Azure, മുതലായവ ലഭ്യമായ സവിശേഷതകൾ: ഡാറ്റാബേസും ഫയൽ സിൻക്രൊണൈസേഷനും, മൾട്ടി-മാസ്റ്റർ ഡാറ്റാബേസ് റെപ്ലിക്കേഷൻ, ഫിൽട്ടർ ചെയ്ത സിൻക്രൊണൈസേഷൻ, ട്രാൻസ്ഫോർമേഷൻ എന്നിവയും മറ്റുള്ളവയും. ഇതൊരു ജാവ ടൂളാണ് കൂടാതെ JRE അല്ലെങ്കിൽ JDK (പതിപ്പ് 8.0 അല്ലെങ്കിൽ ഉയർന്നത്) യുടെ ഒരു സ്റ്റാൻഡേർഡ് റിലീസ് ആവശ്യമാണ്. ഇവിടെ, ഉറവിട ഡാറ്റാബേസിലെ ട്രിഗറുകളിലേക്കുള്ള ഡാറ്റ മാറ്റങ്ങൾ റെക്കോർഡ് ചെയ്യാനും ബാച്ചുകളുടെ രൂപത്തിൽ ഉചിതമായ ടാർഗെറ്റ് ഡാറ്റാബേസിലേക്ക് അയയ്ക്കാനും കഴിയും.

SymmetricDS സവിശേഷതകൾ

ഉപകരണം പ്ലാറ്റ്‌ഫോം സ്വതന്ത്രമാണ്, അതായത് രണ്ടോ അതിലധികമോ വ്യത്യസ്ത ഡാറ്റാബേസുകൾക്ക് ഡാറ്റ കൈമാറാൻ കഴിയും.
റിലേഷണൽ ഡാറ്റാബേസുകൾ ഡാറ്റ മാറ്റ റെക്കോർഡുകൾ ഉപയോഗിച്ച് സമന്വയിപ്പിക്കപ്പെടുന്നു, അതേസമയം ഫയൽ സിസ്റ്റം അടിസ്ഥാനമാക്കിയുള്ള ഡാറ്റാബേസുകൾ ഫയൽ സിൻക്രൊണൈസേഷൻ ഉപയോഗിക്കുന്നു.
ഒരു കൂട്ടം നിയമങ്ങളെ അടിസ്ഥാനമാക്കി പുഷ് ആൻഡ് പുൾ രീതികൾ ഉപയോഗിച്ച് ടു-വേ റെപ്ലിക്കേഷൻ.
സുരക്ഷിതവും കുറഞ്ഞ ബാൻഡ്‌വിഡ്ത്ത് നെറ്റ്‌വർക്കുകളും വഴി ഡാറ്റ കൈമാറ്റം സാധ്യമാണ്.
ഒരു പരാജയത്തിനും സ്വയമേവയുള്ള വൈരുദ്ധ്യ പരിഹാരത്തിനും ശേഷം നോഡുകൾ പ്രവർത്തനം പുനരാരംഭിക്കുമ്പോൾ സ്വയമേവ വീണ്ടെടുക്കൽ.
ക്ലൗഡ് അനുയോജ്യവും ശക്തവുമായ വിപുലീകരണ API-കൾ.

ഉദാഹരണം:

രണ്ട് ഓപ്ഷനുകളിലൊന്നിൽ SymmetricDS കോൺഫിഗർ ചെയ്യാവുന്നതാണ്:
രണ്ട് സ്ലേവ് (ചൈൽഡ്) നോഡുകൾ തമ്മിലുള്ള ഡാറ്റ റെപ്ലിക്കേഷൻ കേന്ദ്രീകൃതമായി ഏകോപിപ്പിക്കുന്ന ഒരു മാസ്റ്റർ (രക്ഷാകർതൃ) നോഡ്, ചൈൽഡ് നോഡുകൾ തമ്മിലുള്ള ആശയവിനിമയം മാതാപിതാക്കളിലൂടെ മാത്രമേ സംഭവിക്കൂ.
ഒരു സജീവ നോഡിന് (നോഡ് 1) ഒരു ഇടനിലക്കാരനില്ലാതെ മറ്റൊരു സജീവ നോഡുമായി (നോഡ് 2) പകർപ്പിനായി ആശയവിനിമയം നടത്താൻ കഴിയും.

രണ്ട് ഓപ്ഷനുകളിലും, പുഷ് ആൻഡ് പുൾ ഉപയോഗിച്ച് ഡാറ്റ കൈമാറ്റം സംഭവിക്കുന്നു. ഈ ഉദാഹരണത്തിൽ നമ്മൾ ഒരു സജീവ-സജീവ കോൺഫിഗറേഷൻ പരിഗണിക്കും. മുഴുവൻ വാസ്തുവിദ്യയും വിവരിക്കാൻ വളരെയധികം സമയമെടുക്കും, അതിനാൽ നിങ്ങളുടെ ഗവേഷണം നടത്തുക. നേതൃത്വംSymmetricDS ഉപകരണത്തെക്കുറിച്ച് കൂടുതലറിയാൻ.

SymmetricDS ഇൻസ്റ്റാൾ ചെയ്യുന്നത് വളരെ ലളിതമാണ്: zip ഫയലിന്റെ ഓപ്പൺ സോഴ്സ് പതിപ്പ് ഡൗൺലോഡ് ചെയ്യുക ഇവിടെ നിന്ന് നിങ്ങൾക്ക് ആവശ്യമുള്ളിടത്ത് അത് പുറത്തെടുക്കുക. ഈ ഉദാഹരണത്തിലെ ഇൻസ്റ്റലേഷൻ ലൊക്കേഷനും SymmetricDS-ന്റെ പതിപ്പും, കൂടാതെ ഡാറ്റാബേസ് പതിപ്പുകൾ, Linux പതിപ്പുകൾ, IP വിലാസങ്ങൾ, രണ്ട് നോഡുകൾക്കുമുള്ള പോർട്ടുകൾ എന്നിവയെ കുറിച്ചുള്ള വിവരങ്ങൾ ചുവടെയുള്ള പട്ടിക നൽകുന്നു.

ഹോസ്റ്റ്
vm1
vm2

OS പതിപ്പ്
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64

ഡിബി സെർവർ പതിപ്പ്
MySQL 5.7.26
PostgreSQL 10.5

ഡിബി പോർട്ട്
3306
5832

IP വിലാസം
192.168.1.107
192.168.1.112

SymmetricDS പതിപ്പ്
സിമെട്രിക്ഡിഎസ് 3.9
സിമെട്രിക്ഡിഎസ് 3.9

SymmetricDS ഇൻസ്റ്റലേഷൻ പാത
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20

SymmetricDS നോഡിന്റെ പേര്
corp-000
സ്റ്റോർ-001

ഇവിടെ ഞങ്ങൾ /usr/local/symmetric-server-3.9.20-ൽ SymmetricDS ഇൻസ്റ്റാൾ ചെയ്യുന്നു, കൂടാതെ വിവിധ സബ്ഡയറക്‌ടറികളും ഫയലുകളും അവിടെ സംഭരിക്കപ്പെടും. സാമ്പിളുകളിലും എഞ്ചിനുകളുടെ ഉപഡയറക്‌ടറികളിലും ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട്. സാമ്പിൾ ഡയറക്‌ടറിയിൽ നോഡ് പ്രോപ്പർട്ടികളുള്ള ഉദാഹരണ കോൺഫിഗറേഷൻ ഫയലുകളും നിങ്ങൾ വേഗത്തിൽ ആരംഭിക്കുന്നതിനുള്ള ഉദാഹരണ SQL സ്ക്രിപ്റ്റുകളും അടങ്ങിയിരിക്കുന്നു.

സാമ്പിൾ ഡയറക്‌ടറിയിൽ നോഡ് പ്രോപ്പർട്ടികളുള്ള മൂന്ന് കോൺഫിഗറേഷൻ ഫയലുകൾ ഞങ്ങൾ കാണുന്നു - പേര് ഒരു നിശ്ചിത സ്കീമിലെ നോഡിന്റെ സ്വഭാവം കാണിക്കുന്നു.

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

അടിസ്ഥാന 3-നോഡ് ഡിസൈനിന് (ഓപ്ഷൻ 1) ആവശ്യമായ എല്ലാ കോൺഫിഗറേഷൻ ഫയലുകളും SymmetricDS-ൽ ഉണ്ട്, അതേ ഫയലുകൾ 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 സമന്വയത്തിനായി നോഡിലേക്കുള്ള കണക്ഷന്റെ സ്ഥാനം കാണിക്കുന്നു.

ഹോസ്റ്റ് vm2-ലെ നോഡ് 2 സ്റ്റോർ-001 ആയി ക്രമീകരിച്ചിരിക്കുന്നു, ബാക്കിയുള്ളവ ചുവടെയുള്ള node.properties ഫയലിൽ വ്യക്തമാക്കിയിരിക്കുന്നു. നോഡ് സ്റ്റോർ-001 PostgreSQL ഡാറ്റാബേസും pgdb_replica റെപ്ലിക്കേഷൻ ഡാറ്റാബേസും പ്രവർത്തിപ്പിക്കുന്നു. രജിസ്ട്രേഷൻ.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 പട്ടികകളുള്ള ഒരു ഉദാഹരണ സ്കീമ സൃഷ്ടിക്കും. symadmin കമാൻഡ് ഉപയോഗിച്ച് create-sym-tables പ്രവർത്തിപ്പിക്കുന്നത്, നോഡുകൾക്കിടയിലുള്ള പകർപ്പിന്റെ നിയമങ്ങളും ദിശയും സംഭരിക്കുന്ന ഡയറക്ടറി പട്ടികകൾ സൃഷ്ടിക്കുന്നു. അവസാനമായി, സാമ്പിൾ ഡാറ്റ പട്ടികകളിലേക്ക് ലോഡ് ചെയ്യുന്നു.

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 and sale_return_line_item) സ്‌റ്റോർ-001-ൽ നിന്ന് corp-000-ലേക്ക് പകർത്താൻ സ്വയമേ കോൺഫിഗർ ചെയ്‌തിരിക്കുന്നു. corp-2-ൽ നിന്ന് ഡാറ്റ സ്വീകരിക്കുന്നതിന് അത് തയ്യാറാക്കുന്നതിനായി ഞങ്ങൾ ഇപ്പോൾ ഹോസ്റ്റ് vm001 (സ്റ്റോർ-000)-ലെ PostgreSQL ഡാറ്റാബേസിൽ ഒരു സ്കീമ സൃഷ്ടിക്കുന്നു.

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

vm1-ലെ MySQL ഡാറ്റാബേസിൽ ഉദാഹരണ പട്ടികകളും SymmetricDS കാറ്റലോഗ് ടേബിളുകളും ഉണ്ടെന്ന് ഉറപ്പാക്കുക. SymmetricDS സിസ്റ്റം ടേബിളുകൾ (sym_ എന്ന പ്രിഫിക്‌സ് ഉള്ളത്) നോഡ് corp-000-ൽ മാത്രമേ നിലവിൽ ലഭ്യമുള്ളൂ എന്ന കാര്യം ശ്രദ്ധിക്കുക, കാരണം അവിടെയാണ് ഞങ്ങൾ create-sym-tables കമാൻഡ് പ്രവർത്തിപ്പിച്ചത്, കൂടാതെ റെപ്ലിക്കേഷൻ കൈകാര്യം ചെയ്യും. നോഡ് സ്റ്റോർ-001-ലെ ഡാറ്റാബേസിൽ ഡാറ്റയില്ലാതെ 4 ഉദാഹരണ പട്ടികകൾ മാത്രമേ ഉണ്ടാകൂ.

എല്ലാം. താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ രണ്ട് നോഡുകളിലും സിം സെർവർ പ്രക്രിയകൾ പ്രവർത്തിപ്പിക്കാൻ പരിസ്ഥിതി തയ്യാറാണ്.

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

SymmetricDS ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള ഡയറക്‌ടറിയിലെ ലോഗ് ഫോൾഡറിലെ ഒരു പശ്ചാത്തല ലോഗ് ഫയലിലേക്ക് (symmetric.log) ലോഗ് എൻട്രികൾ അയയ്‌ക്കുന്നു, അതുപോലെ തന്നെ സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ടിലേക്കും. നോഡ് സ്റ്റോർ-001-ൽ ഇപ്പോൾ സിം സെർവർ ആരംഭിക്കാൻ കഴിയും.

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

നിങ്ങൾ vm2 ഹോസ്റ്റിൽ സിം സെർവർ പ്രോസസ്സ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, അത് PostgreSQL ഡാറ്റാബേസിൽ SymmetricDS കാറ്റലോഗ് പട്ടികകളും സൃഷ്ടിക്കും. നിങ്ങൾ രണ്ട് നോഡുകളിലും സിം സെർവർ പ്രോസസ്സ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, corp-000 മുതൽ store-001 വരെയുള്ള ഡാറ്റ പകർത്തുന്നതിന് അവ പരസ്പരം ഏകോപിപ്പിക്കുന്നു. കുറച്ച് നിമിഷങ്ങൾക്ക് ശേഷം ഞങ്ങൾ ഇരുവശത്തുമുള്ള 4 ടേബിളുകളും അന്വേഷിച്ചാൽ, പകർത്തൽ വിജയകരമാണെന്ന് നമുക്ക് കാണാം. അല്ലെങ്കിൽ താഴെ പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് corp-001-ൽ നിന്ന് node store-000-ലേക്ക് ബൂട്ട്സ്ട്രാപ്പ് അയയ്ക്കാം.

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

ഈ ഘട്ടത്തിൽ, നോഡ് corp-000 (ഹോസ്റ്റ്: vm1)-ലെ MySQL ഡാറ്റാബേസിലെ ഐറ്റം ടേബിളിൽ ഒരു പുതിയ റെക്കോർഡ് ചേർക്കുന്നു, കൂടാതെ നിങ്ങൾക്ക് നോഡ് സ്റ്റോർ-001-ലെ PostgreSQL ഡാറ്റാബേസിലേക്ക് അതിന്റെ പകർപ്പ് പരിശോധിക്കാം (ഹോസ്റ്റ്: 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)

സ്റ്റോർ-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 ആർഗ്യുമെന്റ് ഉപയോഗിച്ച്, ഇത് പട്ടികയുടെ നിർവചനങ്ങൾ മാപ്പ് ചെയ്യുന്നതിനുള്ള ട്രിഗറുകൾ പുനഃസൃഷ്ടിക്കുന്നു. നോഡ് സ്റ്റോർ-001-ലേക്ക് സ്കീമ മാറ്റങ്ങൾ അയക്കുന്നതിന് send-schema എക്സിക്യൂട്ട് ചെയ്യുന്നു, കൂടാതെ ടേബിൾ 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 വഴി. IN ഉപയോക്തൃ മാനുവൽ SymmetricDS ഉപയോഗിച്ച് റെപ്ലിക്കേഷൻ സജ്ജീകരിക്കുന്നതിൽ ഉൾപ്പെട്ടിരിക്കുന്ന വിവിധ ആശയങ്ങൾ വിശദമായി വിവരിക്കുന്നു.

അവലംബം: www.habr.com