ჯვარედინი რეპლიკაცია PostgreSQL-სა და MySQL-ს შორის

მე გამოვყოფ PostgreSQL-სა და MySQL-ს შორის ჯვარედინი რეპლიკაციას, ასევე მონაცემთა ორ სერვერს შორის ჯვარედინი რეპლიკაციის დაყენების მეთოდებს. როგორც წესი, ჯვარედინი რეპლიკაციურ მონაცემთა ბაზებს უწოდებენ ჰომოგენურს და ეს არის მოსახერხებელი მეთოდი ერთი RDBMS სერვერიდან მეორეზე გადასასვლელად.

PostgreSQL და MySQL მონაცემთა ბაზები ზოგადად განიხილება ურთიერთობით, მაგრამ დამატებითი გაფართოებებით ისინი გვთავაზობენ NoSQL შესაძლებლობებს. აქ განვიხილავთ რეპლიკაციას PostgreSQL-სა და MySQL-ს შორის რელაციური DBMS პერსპექტივიდან.

ჩვენ არ აღვწერთ მთლიან შიდა მუშაობას, მხოლოდ ძირითად პრინციპებს, რათა თქვენ გექნებათ იდეა მონაცემთა ბაზის სერვერებს შორის რეპლიკაციის კონფიგურაციის, უპირატესობების, შეზღუდვებისა და გამოყენების შემთხვევების შესახებ.

როგორც წესი, რეპლიკაცია ორ იდენტურ მონაცემთა ბაზის სერვერს შორის ხდება ორობით რეჟიმში ან შეკითხვის გამოყენებით მთავარს (მასტერს (ანუ გამომცემელს, მთავარს ან აქტიურ) და სლავს (აბონენტი, ლოდინი ან პასიური) შორის. რეპლიკაციის მიზანია ძირითადი მონაცემთა ბაზის რეალურ დროში ასლის მიწოდება მონურ მხარეს. ამ შემთხვევაში, მონაცემები გადადის სამაგისტროდან მონაზე, ანუ აქტიურიდან პასიურზე, რადგან რეპლიკაცია ხორციელდება მხოლოდ ერთი მიმართულებით. მაგრამ თქვენ შეგიძლიათ დააყენოთ რეპლიკაცია ორ მონაცემთა ბაზას შორის ორივე მიმართულებით, ისე, რომ მონაცემები გადაეცეს სლავიდან მთავარს აქტიურ-აქტიურ კონფიგურაციაში. ეს ყველაფერი, მათ შორის კასკადური რეპლიკაცია, შესაძლებელია მონაცემთა ბაზის ორ ან მეტ იდენტურ სერვერს შორის.აქტიურ-აქტიური ან აქტიურ-პასიური კონფიგურაცია დამოკიდებულია საჭიროებაზე, ასეთი შესაძლებლობების ხელმისაწვდომობაზე საწყის კონფიგურაციაში ან გარე კონფიგურაციის გადაწყვეტილებების გამოყენებაზე და არსებულ კომპრომისებზე.

აღწერილი კონფიგურაცია შესაძლებელია მონაცემთა ბაზის სხვადასხვა სერვერებს შორის. სერვერის კონფიგურაცია შესაძლებელია ისე, რომ მიიღოს ტირაჟირებული მონაცემები მონაცემთა ბაზის სხვა სერვერიდან და კვლავ შეინახოს რეპლიკაციური მონაცემების რეალურ დროში სნეპშოტები. 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 ასლიდან.
ცხრილები, რომლებსაც არ შეუძლიათ გამეორება ან შეცდომების წარმოქმნა, გამორიცხულია.
რეპლიკაციის თითოეულ ფუნქციას აკონტროლებენ დემონები.
კონტროლი YAML-ზე დაფუძნებული პარამეტრების და კონფიგურაციის ფაილების მეშვეობით.

მაგალითი

მასპინძელი
vm1
vm2

OS ვერსია
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64

DB სერვერის ვერსია
MySQL 5.7.26
10.5

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 (ქამელეონი არის ბრძანება) 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 კონფიგურაციის ფაილში არის გლობალური პარამეტრების განყოფილება, სადაც შეგიძლიათ მართოთ ისეთი პარამეტრები, როგორიცაა დაბლოკვის ფაილის მდებარეობა, ჟურნალების მდებარეობა, ჟურნალების შენახვის პერიოდი და ა.შ. შემდეგ მოდის type override განყოფილება, სადაც რეპლიკაციის დროს ტიპების გადაჭარბების წესების ნაკრები. მაგალითში ნაგულისხმევია ტიპის უმთავრესი წესი, რომელიც გარდაქმნის 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 (ქამელეონი) ბრძანება ამზადებს გარემოს, ამატებს წყაროს და ახდენს რეპლიკას ინიციალიზაციას. არგუმენტი 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 მეთოდების გამოყენებით წესების ნაკრების საფუძველზე.
მონაცემთა გადაცემა შესაძლებელია უსაფრთხო და დაბალი გამტარუნარიანობის ქსელებით.
ავტომატური აღდგენა, როდესაც კვანძები განაახლებს მუშაობას წარუმატებლობისა და კონფლიქტის ავტომატური მოგვარების შემდეგ.
ღრუბელთან თავსებადი და ძლიერი გაფართოების API-ები.

მაგალითი

SymmetricDS შეიძლება კონფიგურირებული იყოს ორიდან ერთ-ერთ ვარიანტში:
სამაგისტრო (მშობელი) კვანძი, რომელიც ცენტრალიზებულად კოორდინაციას უწევს მონაცემთა რეპლიკაციას ორ მონა (შვილი) კვანძს შორის, ხოლო შვილობილ კვანძებს შორის კომუნიკაცია ხდება მხოლოდ მშობლის მეშვეობით.
აქტიურ კვანძს (Node 1) შეუძლია რეპლიკაციისთვის დაუკავშირდეს სხვა აქტიურ კვანძს (Node 2) შუამავლის გარეშე.

ორივე ვარიანტში მონაცემთა გაცვლა ხდება Push-ისა და Pull-ის გამოყენებით. ამ მაგალითში განვიხილავთ აქტიურ-აქტიურ კონფიგურაციას. მთელი არქიტექტურის აღწერას ძალიან დიდი დრო დასჭირდება, ასე რომ, გააკეთეთ თქვენი კვლევა. ხელმძღვანელობარომ შეიტყოთ მეტი SymmetricDS მოწყობილობის შესახებ.

SymmetricDS-ის ინსტალაცია ძალიან მარტივია: ჩამოტვირთეთ zip ფაილის ღია კოდის ვერსია აქედან გამომდინარე, და წაიღეთ სადაც გინდათ. ქვემოთ მოცემული ცხრილი შეიცავს ინფორმაციას ამ მაგალითში SymmetricDS-ის ინსტალაციის ადგილმდებარეობისა და ვერსიის შესახებ, ასევე მონაცემთა ბაზის ვერსიების, Linux-ის ვერსიების, IP მისამართების და ორივე კვანძის პორტების შესახებ.

მასპინძელი
vm1
vm2

OS ვერსია
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64

DB სერვერის ვერსია
MySQL 5.7.26
10.5

DB პორტი
3306
5832

IP მისამართი
192.168.1.107
192.168.1.112

SymmetricDS ვერსია
SymmetricDS 3.9
SymmetricDS 3.9

SymmetricDS ინსტალაციის გზა
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20

SymmetricDS კვანძის სახელი
კორპ-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 ცხრილით. შემდეგ შექმნა-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

მაგალითში, საქონლისა და ნივთის_გაყიდვის_ფასის ცხრილები ავტომატურად არის კონფიგურირებული, რათა განმეორდეს 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 მაგალითი ცხრილი მონაცემთა გარეშე.

ყველა. გარემო მზადაა იმისთვის, რომ სიმ სერვერის პროცესები გაუშვას ორივე კვანძზე, როგორც ეს ნაჩვენებია ქვემოთ.

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

ჟურნალის ჩანაწერები იგზავნება ფონის ჟურნალის ფაილში (symmetric.log) ჟურნალების საქაღალდეში იმ დირექტორიაში, სადაც დაინსტალირებულია SymmetricDS, ასევე სტანდარტულ გამომავალში. Sym სერვერის ინიცირება ახლა შესაძლებელია node store-001-ზე.

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

თუ თქვენ აწარმოებთ sym სერვერის პროცესს vm2 ჰოსტზე, ის ასევე შექმნის SymmetricDS კატალოგის ცხრილებს PostgreSQL მონაცემთა ბაზაში. თუ თქვენ აწარმოებთ sym სერვერის პროცესს ორივე კვანძზე, ისინი კოორდინაციას უწევენ ერთმანეთს, რათა გაიმეორონ მონაცემები corp-000-დან store-001-მდე. თუ რამდენიმე წამის შემდეგ გამოვიკითხავთ ოთხივე ცხრილს ორივე მხრიდან, დავინახავთ, რომ რეპლიკაცია წარმატებული იყო. ან შეგიძლიათ გაგზავნოთ bootstrap node store-4-ში corp-001-დან შემდეგი ბრძანებით.

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

ამ ეტაპზე, ახალი ჩანაწერი ჩასმულია ელემენტის ცხრილში MySQL მონაცემთა ბაზაში node corp-000-ზე (მასპინძელი: vm1) და შეგიძლიათ შეამოწმოთ მისი რეპლიკაცია PostgreSQL მონაცემთა ბაზაში node store-001-ზე (მასპინძელი: vm2). ჩვენ ვხედავთ Pull ოპერაციას მონაცემების გადასატანად corp-000-დან store-001-ში.

mysql> insert into item values ('22000002','Jelly Bean');
Query OK, 1 row affected (0.00 sec)

vm2$> psql -p 5832 -U postgres pgdb_replica -c "select * from item"
 item_id  |   name
----------+-----------
 11000001 | Yummy Gum
 22000002 | Jelly Bean
(2 rows)

Push ოპერაციის შესასრულებლად მონაცემების store-001-დან corp-000-ში გადასატანად, ჩვენ ჩავსვამთ ჩანაწერს sale_transaction ცხრილში და ვამოწმებთ, რომ რეპლიკაცია წარმატებით დასრულდა.

შედეგი.

ჩვენ ვხედავთ მაგალითების ცხრილების ორმხრივი რეპლიკაციის წარმატებულ დაყენებას MySQL და PostgreSQL მონაცემთა ბაზებს შორის. ახალი მომხმარებლის ცხრილებისთვის რეპლიკაციის დასაყენებლად, მიჰყევით ამ ნაბიჯებს: ჩვენ ვქმნით ცხრილს t1 მაგალითად და ვაკონფიგურირებთ მისი რეპლიკაციის წესებს შემდეგნაირად. ამ გზით ჩვენ ვაკონფიგურირებთ მხოლოდ რეპლიკაციას 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 შესრულებულია სქემის ცვლილებების გასაგზავნად 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