PostgreSQL ಮತ್ತು MySQL ನಡುವೆ ಕ್ರಾಸ್ ರೆಪ್ಲಿಕೇಶನ್

ನಾನು PostgreSQL ಮತ್ತು MySQL ನಡುವೆ ಅಡ್ಡ-ಪ್ರತಿಕೃತಿಯನ್ನು ರೂಪಿಸುತ್ತೇನೆ, ಹಾಗೆಯೇ ಎರಡು ಡೇಟಾಬೇಸ್ ಸರ್ವರ್‌ಗಳ ನಡುವೆ ಕ್ರಾಸ್-ರಿಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿಸುವ ವಿಧಾನಗಳು. ವಿಶಿಷ್ಟವಾಗಿ, ಕ್ರಾಸ್-ರಿಪ್ಲಿಕೇಟೆಡ್ ಡೇಟಾಬೇಸ್‌ಗಳನ್ನು ಏಕರೂಪದ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಇದು ಒಂದು RDBMS ಸರ್ವರ್‌ನಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಚಲಿಸುವ ಅನುಕೂಲಕರ ವಿಧಾನವಾಗಿದೆ.

PostgreSQL ಮತ್ತು MySQL ಡೇಟಾಬೇಸ್‌ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಬಂಧಿತವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಹೆಚ್ಚುವರಿ ವಿಸ್ತರಣೆಗಳೊಂದಿಗೆ ಅವು NoSQL ಸಾಮರ್ಥ್ಯಗಳನ್ನು ನೀಡುತ್ತವೆ. ಸಂಬಂಧಿತ DBMS ದೃಷ್ಟಿಕೋನದಿಂದ PostgreSQL ಮತ್ತು MySQL ನಡುವಿನ ಪ್ರತಿಕೃತಿಯನ್ನು ನಾವು ಇಲ್ಲಿ ಚರ್ಚಿಸುತ್ತೇವೆ.

ನಾವು ಸಂಪೂರ್ಣ ಆಂತರಿಕ ಕಾರ್ಯಗಳನ್ನು ವಿವರಿಸುವುದಿಲ್ಲ, ಕೇವಲ ಮೂಲಭೂತ ತತ್ವಗಳು ಇದರಿಂದ ಡೇಟಾಬೇಸ್ ಸರ್ವರ್‌ಗಳು, ಅನುಕೂಲಗಳು, ಮಿತಿಗಳು ಮತ್ತು ಬಳಕೆಯ ಸಂದರ್ಭಗಳ ನಡುವೆ ಪ್ರತಿಕೃತಿಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ಕಲ್ಪನೆಯನ್ನು ನೀವು ಪಡೆಯುತ್ತೀರಿ.

ವಿಶಿಷ್ಟವಾಗಿ, ಎರಡು ಒಂದೇ ಡೇಟಾಬೇಸ್ ಸರ್ವರ್‌ಗಳ ನಡುವಿನ ಪ್ರತಿಕೃತಿಯನ್ನು ಬೈನರಿ ಮೋಡ್‌ನಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ ಅಥವಾ ಮಾಸ್ಟರ್ (a.k.a. ಪ್ರಕಾಶಕರು, ಮಾಸ್ಟರ್, ಅಥವಾ ಸಕ್ರಿಯ) ಮತ್ತು ಸ್ಲೇವ್ (ಚಂದಾದಾರರು, ಸ್ಟ್ಯಾಂಡ್‌ಬೈ, ಅಥವಾ ನಿಷ್ಕ್ರಿಯ) ನಡುವಿನ ಪ್ರಶ್ನೆಗಳನ್ನು ಬಳಸುತ್ತಾರೆ. ಸ್ಲೇವ್ ಸೈಡ್‌ನಲ್ಲಿ ಮಾಸ್ಟರ್ ಡೇಟಾಬೇಸ್‌ನ ನೈಜ-ಸಮಯದ ನಕಲನ್ನು ಒದಗಿಸುವುದು ಪ್ರತಿಕೃತಿಯ ಉದ್ದೇಶವಾಗಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಡೇಟಾವನ್ನು ಮಾಸ್ಟರ್‌ನಿಂದ ಸ್ಲೇವ್‌ಗೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ ಸಕ್ರಿಯದಿಂದ ನಿಷ್ಕ್ರಿಯಕ್ಕೆ, ಏಕೆಂದರೆ ಪ್ರತಿಕೃತಿಯನ್ನು ಒಂದು ದಿಕ್ಕಿನಲ್ಲಿ ಮಾತ್ರ ನಡೆಸಲಾಗುತ್ತದೆ. ಆದರೆ ನೀವು ಎರಡೂ ದಿಕ್ಕುಗಳಲ್ಲಿ ಎರಡು ಡೇಟಾಬೇಸ್‌ಗಳ ನಡುವೆ ಪ್ರತಿಕೃತಿಯನ್ನು ಹೊಂದಿಸಬಹುದು, ಇದರಿಂದಾಗಿ ಡೇಟಾವನ್ನು ಸಕ್ರಿಯ-ಸಕ್ರಿಯ ಸಂರಚನೆಯಲ್ಲಿ ಸ್ಲೇವ್‌ನಿಂದ ಮಾಸ್ಟರ್‌ಗೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ. ಕ್ಯಾಸ್ಕೇಡಿಂಗ್ ರೆಪ್ಲಿಕೇಶನ್ ಸೇರಿದಂತೆ ಇವೆಲ್ಲವೂ ಎರಡು ಅಥವಾ ಹೆಚ್ಚು ಒಂದೇ ಡೇಟಾಬೇಸ್ ಸರ್ವರ್‌ಗಳ ನಡುವೆ ಸಾಧ್ಯ.ಸಕ್ರಿಯ-ಸಕ್ರಿಯ ಅಥವಾ ಸಕ್ರಿಯ-ನಿಷ್ಕ್ರಿಯ ಸಂರಚನೆಯು ಆರಂಭಿಕ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ ಅಂತಹ ಸಾಮರ್ಥ್ಯಗಳ ಲಭ್ಯತೆ ಅಥವಾ ಬಾಹ್ಯ ಕಾನ್ಫಿಗರೇಶನ್ ಪರಿಹಾರಗಳು ಮತ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ವ್ಯಾಪಾರ-ವಹಿವಾಟುಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ.

ವಿವರಿಸಿದ ಸಂರಚನೆಯು ವಿಭಿನ್ನ ಡೇಟಾಬೇಸ್ ಸರ್ವರ್‌ಗಳ ನಡುವೆ ಸಾಧ್ಯ. ಮತ್ತೊಂದು ಡೇಟಾಬೇಸ್ ಸರ್ವರ್‌ನಿಂದ ನಕಲಿ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಲು ಸರ್ವರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು ಮತ್ತು ನಕಲಿ ಡೇಟಾದ ನೈಜ-ಸಮಯದ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳನ್ನು ಇನ್ನೂ ನಿರ್ವಹಿಸಬಹುದು. MySQL ಮತ್ತು PostgreSQL ಬೈನರಿ ಲಾಗ್ ವಿಧಾನಗಳು, ಡಿಸ್ಕ್ ಲಾಕಿಂಗ್ ಮತ್ತು ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಮತ್ತು ರೋ-ಆಧಾರಿತ ವಿಧಾನಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಈ ಹೆಚ್ಚಿನ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ಮನೆಯಲ್ಲಿಯೇ ಅಥವಾ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ವಿಸ್ತರಣೆಗಳ ಮೂಲಕ ನೀಡುತ್ತವೆ.

MySQL ಮತ್ತು PostgreSQL ನಡುವಿನ ಕ್ರಾಸ್ ರೆಪ್ಲಿಕೇಶನ್ ಒಂದು ಡೇಟಾಬೇಸ್ ಸರ್ವರ್‌ನಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಒಂದು ಬಾರಿ ವಲಸೆಯ ಅಗತ್ಯವಿದೆ. ಈ ಡೇಟಾಬೇಸ್‌ಗಳು ವಿಭಿನ್ನ ಪ್ರೋಟೋಕಾಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ನೇರವಾಗಿ ಲಿಂಕ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಡೇಟಾ ವಿನಿಮಯವನ್ನು ಸ್ಥಾಪಿಸಲು, ನೀವು ಬಾಹ್ಯ ತೆರೆದ ಮೂಲ ಉಪಕರಣವನ್ನು ಬಳಸಬಹುದು, ಉದಾಹರಣೆಗೆ pg_chameleon.

ಪಿಜಿ_ಗೋಸುಂಬೆ ಎಂದರೇನು

pg_chameleon ಎಂಬುದು ಪೈಥಾನ್ 3 ರಲ್ಲಿ MySQL ನಿಂದ PostgreSQL ಗೆ ಒಂದು ಪುನರಾವರ್ತನೆಯ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ. ಇದು ಪೈಥಾನ್‌ನಲ್ಲಿಯೂ ಸಹ ಓಪನ್ ಸೋರ್ಸ್ mysql-ರೆಪ್ಲಿಕೇಶನ್ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತದೆ. ಸಾಲು ಚಿತ್ರಗಳನ್ನು 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 ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಕೆಳಗಿನ ಆಜ್ಞೆಗಳು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ 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 ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ಮತ್ತು ಡೀಫಾಲ್ಟ್ ಡೈರೆಕ್ಟರಿಗಳು ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸಲು 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 (ಊಸರವಳ್ಳಿ) ಆಜ್ಞೆಗಳು ಪರಿಸರವನ್ನು ಸಿದ್ಧಪಡಿಸುತ್ತವೆ, ಮೂಲವನ್ನು ಸೇರಿಸುತ್ತವೆ ಮತ್ತು ಪ್ರತಿಕೃತಿಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತವೆ. Pg_chameleon ಗೆ create_replica_schema ಆರ್ಗ್ಯುಮೆಂಟ್ ನಾವು ಈಗಾಗಲೇ ಚರ್ಚಿಸಿದಂತೆ PostgreSQL ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಡೀಫಾಲ್ಟ್ ಸ್ಕೀಮಾ (sch_chameleon) ಮತ್ತು ರೆಪ್ಲಿಕೇಶನ್ ಸ್ಕೀಮಾ (pgworld_x) ಅನ್ನು ರಚಿಸುತ್ತದೆ. 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

ಶೋ_ಸ್ಟೇಟಸ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪುನರಾವರ್ತನೆಯ ಸ್ಥಿತಿಯನ್ನು ಪ್ರಶ್ನಿಸಬಹುದು ಮತ್ತು ಶೋ_ಎರರ್ಸ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ದೋಷಗಳನ್ನು ವೀಕ್ಷಿಸಬಹುದು.

ಫಲಿತಾಂಶ.

ನಾವು ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ, ಪ್ರತಿ ನಕಲು ಕಾರ್ಯವನ್ನು ಡೀಮನ್‌ಗಳು ನಿಯಂತ್ರಿಸುತ್ತವೆ. ಅವುಗಳನ್ನು ವೀಕ್ಷಿಸಲು, ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ನಾವು Linux ps ಆಜ್ಞೆಯೊಂದಿಗೆ ಪ್ರಕ್ರಿಯೆ ಕೋಷ್ಟಕವನ್ನು ಪ್ರಶ್ನಿಸುತ್ತೇವೆ.

ಫಲಿತಾಂಶ.

ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ನಾವು ನೈಜ ಸಮಯದಲ್ಲಿ ಅದನ್ನು ಪರೀಕ್ಷಿಸುವವರೆಗೆ ಪ್ರತಿಕೃತಿಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ ಎಂದು ಪರಿಗಣಿಸಲಾಗುವುದಿಲ್ಲ. ನಾವು ಟೇಬಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ, MySQL ಡೇಟಾಬೇಸ್‌ಗೆ ಒಂದೆರಡು ದಾಖಲೆಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ ಮತ್ತು ಡೀಮನ್‌ಗಳನ್ನು ನವೀಕರಿಸಲು ಮತ್ತು ಪೋಸ್ಟ್‌ಗ್ರೆಎಸ್‌ಕ್ಯುಎಲ್ ಡೇಟಾಬೇಸ್‌ಗೆ ರೆಕಾರ್ಡ್‌ಗಳೊಂದಿಗೆ ಟೇಬಲ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸಲು pg_chameleon ನಲ್ಲಿ ಸಿಂಕ್_ಟೇಬಲ್ಸ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಕರೆಯುತ್ತೇವೆ.

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 ಸರ್ವರ್, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird ಮತ್ತು ಇತರ ಕ್ಲೌಡ್ ಡೇಟಾಬೇಸ್ ನಿದರ್ಶನಗಳು, ಉದಾ. ಅಜೂರ್, ಇತ್ಯಾದಿ ಲಭ್ಯವಿರುವ ವೈಶಿಷ್ಟ್ಯಗಳು: ಡೇಟಾಬೇಸ್ ಮತ್ತು ಫೈಲ್ ಸಿಂಕ್ರೊನೈಸೇಶನ್, ಮಲ್ಟಿ-ಮಾಸ್ಟರ್ ಡೇಟಾಬೇಸ್ ರೆಪ್ಲಿಕೇಶನ್, ಫಿಲ್ಟರ್ ಮಾಡಿದ ಸಿಂಕ್ರೊನೈಸೇಶನ್, ರೂಪಾಂತರ ಮತ್ತು ಇತರರು. ಇದು ಜಾವಾ ಸಾಧನವಾಗಿದೆ ಮತ್ತು JRE ಅಥವಾ JDK (ಆವೃತ್ತಿ 8.0 ಅಥವಾ ಹೆಚ್ಚಿನದು) ಯ ಪ್ರಮಾಣಿತ ಬಿಡುಗಡೆಯ ಅಗತ್ಯವಿದೆ. ಇಲ್ಲಿ, ಮೂಲ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಟ್ರಿಗ್ಗರ್‌ಗಳಿಗೆ ಡೇಟಾ ಬದಲಾವಣೆಗಳನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡಬಹುದು ಮತ್ತು ಬ್ಯಾಚ್‌ಗಳ ರೂಪದಲ್ಲಿ ಸೂಕ್ತವಾದ ಗುರಿ ಡೇಟಾಬೇಸ್‌ಗೆ ಕಳುಹಿಸಬಹುದು.

ಸಿಮೆಟ್ರಿಕ್ ಡಿಎಸ್ ವೈಶಿಷ್ಟ್ಯಗಳು

ಉಪಕರಣವು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸ್ವತಂತ್ರವಾಗಿದೆ, ಅಂದರೆ ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ವಿಭಿನ್ನ ಡೇಟಾಬೇಸ್‌ಗಳು ಡೇಟಾವನ್ನು ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳಬಹುದು.
ರಿಲೇಷನಲ್ ಡೇಟಾಬೇಸ್‌ಗಳನ್ನು ಡೇಟಾ ಬದಲಾವಣೆಯ ದಾಖಲೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲಾಗುತ್ತದೆ, ಆದರೆ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಆಧಾರಿತ ಡೇಟಾಬೇಸ್‌ಗಳು ಫೈಲ್ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅನ್ನು ಬಳಸುತ್ತವೆ.
ನಿಯಮಗಳ ಗುಂಪನ್ನು ಆಧರಿಸಿ ಪುಶ್ ಮತ್ತು ಪುಲ್ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ದ್ವಿಮುಖ ಪುನರಾವರ್ತನೆ.
ಸುರಕ್ಷಿತ ಮತ್ತು ಕಡಿಮೆ-ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ನೆಟ್‌ವರ್ಕ್‌ಗಳಲ್ಲಿ ಡೇಟಾ ವರ್ಗಾವಣೆ ಸಾಧ್ಯ.
ವೈಫಲ್ಯ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ಸಂಘರ್ಷ ಪರಿಹಾರದ ನಂತರ ನೋಡ್‌ಗಳು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪುನರಾರಂಭಿಸಿದಾಗ ಸ್ವಯಂಚಾಲಿತ ಚೇತರಿಕೆ.
ಮೇಘ ಹೊಂದಾಣಿಕೆಯ ಮತ್ತು ಶಕ್ತಿಯುತ ವಿಸ್ತರಣೆ 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

ಸಿಮೆಟ್ರಿಕ್ ಡಿಎಸ್ ಆವೃತ್ತಿ
ಸಿಮೆಟ್ರಿಕ್ಡಿಎಸ್ 3.9
ಸಿಮೆಟ್ರಿಕ್ಡಿಎಸ್ 3.9

SymmetricDS ಅನುಸ್ಥಾಪನಾ ಮಾರ್ಗ
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20

ಸಿಮೆಟ್ರಿಕ್ ಡಿಎಸ್ ನೋಡ್ ಹೆಸರು
ಕಾರ್ಪೊರೇಷನ್-000
ಅಂಗಡಿ-001

ಇಲ್ಲಿ ನಾವು /usr/local/symmetric-server-3.9.20 ನಲ್ಲಿ SymmetricDS ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ ಮತ್ತು ವಿವಿಧ ಉಪ ಡೈರೆಕ್ಟರಿಗಳು ಮತ್ತು ಫೈಲ್‌ಗಳನ್ನು ಅಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ. ನಾವು ಮಾದರಿಗಳು ಮತ್ತು ಎಂಜಿನ್‌ಗಳ ಉಪ ಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ. ಮಾದರಿಗಳ ಡೈರೆಕ್ಟರಿಯು ನೋಡ್ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಉದಾಹರಣೆ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಹಾಗೆಯೇ ನೀವು ತ್ವರಿತವಾಗಿ ಪ್ರಾರಂಭಿಸಲು ಉದಾಹರಣೆ 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 ತೋರಿಸುತ್ತದೆ.

ಹೋಸ್ಟ್ vm2 ನಲ್ಲಿ ನೋಡ್ 2 ಅನ್ನು ಸ್ಟೋರ್-001 ಎಂದು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಉಳಿದವುಗಳನ್ನು ಕೆಳಗಿನ node.properties ಫೈಲ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ. ನೋಡ್ ಸ್ಟೋರ್-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 ಕೋಷ್ಟಕಗಳೊಂದಿಗೆ ಉದಾಹರಣೆ ಸ್ಕೀಮಾವನ್ನು ರಚಿಸುತ್ತದೆ. ನಂತರ 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 ಮತ್ತು sale_return_line_item) ಸ್ವಯಂಚಾಲಿತವಾಗಿ store-001 ರಿಂದ corp-000 ವರೆಗೆ ಪುನರಾವರ್ತಿಸಲು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗುತ್ತದೆ. ಈಗ ನಾವು corp-2 ನಿಂದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಲು ಅದನ್ನು ಸಿದ್ಧಪಡಿಸಲು ಹೋಸ್ಟ್ vm001 (store-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_ ನೊಂದಿಗೆ ಪೂರ್ವಪ್ರತ್ಯಯ) ಪ್ರಸ್ತುತ node 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 ನಿಂದ ಸ್ಟೋರ್-001 ಗೆ ಡೇಟಾವನ್ನು ಪುನರಾವರ್ತಿಸಲು ಪರಸ್ಪರ ಸಂಯೋಜಿಸುತ್ತವೆ. ಕೆಲವು ಸೆಕೆಂಡುಗಳ ನಂತರ ನಾವು ಎಲ್ಲಾ 4 ಕೋಷ್ಟಕಗಳನ್ನು ಎರಡೂ ಬದಿಗಳಲ್ಲಿ ಪ್ರಶ್ನಿಸಿದರೆ, ಪುನರಾವರ್ತನೆ ಯಶಸ್ವಿಯಾಗಿದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಅಥವಾ ನೀವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ corp-001 ನಿಂದ ನೋಡ್ ಸ್ಟೋರ್-000 ಗೆ ಬೂಟ್‌ಸ್ಟ್ರ್ಯಾಪ್ ಅನ್ನು ಕಳುಹಿಸಬಹುದು.

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

ಈ ಹಂತದಲ್ಲಿ, ನೋಡ್ corp-000 (ಹೋಸ್ಟ್: vm1) ನಲ್ಲಿನ MySQL ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಐಟಂ ಟೇಬಲ್‌ಗೆ ಹೊಸ ದಾಖಲೆಯನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನೀವು ನೋಡ್ ಸ್ಟೋರ್-001 (ಹೋಸ್ಟ್: vm2) ನಲ್ಲಿನ PostgreSQL ಡೇಟಾಬೇಸ್‌ಗೆ ಅದರ ಪ್ರತಿಕೃತಿಯನ್ನು ಪರಿಶೀಲಿಸಬಹುದು. 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 ಗೆ ಡೇಟಾವನ್ನು ಸರಿಸಲು ಪುಶ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು, ನಾವು ಮಾರಾಟ_ವಹಿವಾಟು ಕೋಷ್ಟಕದಲ್ಲಿ ದಾಖಲೆಯನ್ನು ಸೇರಿಸುತ್ತೇವೆ ಮತ್ತು ಪುನರಾವರ್ತನೆ ಯಶಸ್ವಿಯಾಗಿದೆ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತೇವೆ.

ಫಲಿತಾಂಶ.

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)

ಕಾನ್ಫಿಗರೇಶನ್ ನಂತರ ಸ್ಕೀಮಾ ಬದಲಾವಣೆಯ ಬಗ್ಗೆ ತಿಳಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ, ಸಿಂಕ್-ಟ್ರಿಗ್ಗರ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ನೊಂದಿಗೆ ಸಿಮ್ಯಾಡ್‌ಮಿನ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಸ ಟೇಬಲ್‌ನ ಸೇರ್ಪಡೆ, ಇದು ಟೇಬಲ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಮ್ಯಾಪ್ ಮಾಡಲು ಟ್ರಿಗ್ಗರ್‌ಗಳನ್ನು ಮರುಸೃಷ್ಟಿಸುತ್ತದೆ. ಸ್ಕೀಮಾ ಬದಲಾವಣೆಗಳನ್ನು ನೋಡ್ ಸ್ಟೋರ್-001 ಗೆ ಕಳುಹಿಸಲು send-schema ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಟೇಬಲ್ t1 ನ ಪ್ರತಿಕೃತಿಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ.

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

ಸಿಮೆಟ್ರಿಕ್ ಡಿಎಸ್ ನ ಪ್ರಯೋಜನಗಳು

ಮೂರು-ನೋಡ್ ಅಥವಾ ಎರಡು-ನೋಡ್ ಸರ್ಕ್ಯೂಟ್ ರಚಿಸಲು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳೊಂದಿಗೆ ಸಿದ್ಧ-ಸಿದ್ಧ ಫೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಸುಲಭವಾದ ಅನುಸ್ಥಾಪನೆ ಮತ್ತು ಸಂರಚನೆ.
ಸರ್ವರ್‌ಗಳು, ಲ್ಯಾಪ್‌ಟಾಪ್‌ಗಳು ಮತ್ತು ಮೊಬೈಲ್ ಸಾಧನಗಳು ಸೇರಿದಂತೆ ಕ್ರಾಸ್-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಡೇಟಾಬೇಸ್‌ಗಳು ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸ್ವಾತಂತ್ರ್ಯ.
ಸ್ಥಳೀಯವಾಗಿ, WAN ಅಥವಾ ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಯಾವುದೇ ಡೇಟಾಬೇಸ್‌ಗೆ ಯಾವುದೇ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸಿ.
ಅನುಕೂಲಕರ ಪುನರಾವರ್ತನೆಗಾಗಿ ಒಂದೆರಡು ಡೇಟಾಬೇಸ್ ಅಥವಾ ಹಲವಾರು ಸಾವಿರಗಳೊಂದಿಗೆ ಸೂಕ್ತವಾದ ಕೆಲಸದ ಸಾಧ್ಯತೆ.
GUI ಮತ್ತು ಅತ್ಯುತ್ತಮ ಬೆಂಬಲದೊಂದಿಗೆ ಪಾವತಿಸಿದ ಆವೃತ್ತಿ.

ಸಿಮೆಟ್ರಿಕ್ ಡಿಎಸ್ನ ಅನಾನುಕೂಲಗಳು

ಕ್ಯಾಟಲಾಗ್ ಕೋಷ್ಟಕಗಳನ್ನು ಲೋಡ್ ಮಾಡಲು SQL ಹೇಳಿಕೆಗಳ ಮೂಲಕ ಕಮಾಂಡ್ ಲೈನ್‌ನಲ್ಲಿ ಪುನರಾವರ್ತನೆಯ ನಿಯಮಗಳು ಮತ್ತು ದಿಕ್ಕನ್ನು ನೀವು ಹಸ್ತಚಾಲಿತವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಬೇಕಾಗಿದೆ, ಅದು ಅನಾನುಕೂಲವಾಗಬಹುದು.
ಪ್ರತಿಕೃತಿಯ ನಿಯಮಗಳು ಮತ್ತು ದಿಕ್ಕನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ SQL ಹೇಳಿಕೆಗಳನ್ನು ರಚಿಸಲು ನೀವು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬಳಸದ ಹೊರತು ಪುನರಾವರ್ತನೆಗಾಗಿ ಅನೇಕ ಕೋಷ್ಟಕಗಳನ್ನು ಹೊಂದಿಸುವುದು ಬೇಸರದ ಸಂಗತಿಯಾಗಿದೆ.
ಲಾಗ್‌ಗಳಲ್ಲಿ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ದಾಖಲಿಸಲಾಗಿದೆ ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ನೀವು ಲಾಗ್ ಫೈಲ್ ಅನ್ನು ಅಚ್ಚುಕಟ್ಟಾಗಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಇದರಿಂದ ಅದು ಹೆಚ್ಚು ಜಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ.

SymmetricDS ಗಾಗಿ ಫಲಿತಾಂಶಗಳು

ಫೈಲ್‌ಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಮತ್ತು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ಎರಡು, ಮೂರು ಅಥವಾ ಹಲವಾರು ಸಾವಿರ ನೋಡ್‌ಗಳ ನಡುವೆ ದ್ವಿಮುಖ ಪ್ರತಿಕೃತಿಯನ್ನು ಹೊಂದಿಸಲು SymmetricDS ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನೋಡ್‌ನಲ್ಲಿ ದೀರ್ಘಾವಧಿಯ ಅಲಭ್ಯತೆಯ ನಂತರ ಸ್ವಯಂಚಾಲಿತ ಡೇಟಾ ಮರುಪಡೆಯುವಿಕೆ, HTTPS ಮೂಲಕ ನೋಡ್‌ಗಳ ನಡುವೆ ಸುರಕ್ಷಿತ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಡೇಟಾ ವಿನಿಮಯ, ನಿಯಮಗಳ ಆಧಾರದ ಮೇಲೆ ಸ್ವಯಂಚಾಲಿತ ಸಂಘರ್ಷ ನಿರ್ವಹಣೆ, ಇತ್ಯಾದಿಗಳಂತಹ ಅನೇಕ ಕಾರ್ಯಗಳನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ನಿರ್ವಹಿಸುವ ವಿಶಿಷ್ಟ ಸಾಧನವಾಗಿದೆ. SymmetricDS ನಿರ್ವಹಿಸುತ್ತದೆ. ಯಾವುದೇ ಡೇಟಾಬೇಸ್‌ಗಳ ನಡುವಿನ ಪ್ರತಿಕೃತಿ, ಆದ್ದರಿಂದ, ಸ್ಥಳಾಂತರ, ವಲಸೆ, ವಿತರಣೆ, ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಾದ್ಯಂತ ಡೇಟಾದ ರೂಪಾಂತರ ಸೇರಿದಂತೆ ವಿವಿಧ ರೀತಿಯ ಸನ್ನಿವೇಶಗಳಿಗೆ ಇದನ್ನು ಬಳಸಬಹುದು.

ಉದಾಹರಣೆ ಅಧಿಕೃತವನ್ನು ಆಧರಿಸಿದೆ ತ್ವರಿತ ಮಾರ್ಗದರ್ಶಿ ಸಿಮೆಟ್ರಿಕ್ಡಿಎಸ್ ಮೂಲಕ. IN ಬಳಕೆದಾರರ ಕೈಪಿಡಿ SymmetricDS ನೊಂದಿಗೆ ಪ್ರತಿಕೃತಿಯನ್ನು ಹೊಂದಿಸುವಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ವಿವಿಧ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ವಿವರವಾಗಿ ವಿವರಿಸುತ್ತದೆ.

ಮೂಲ: www.habr.com