PostgreSQL અને MySQL વચ્ચે ક્રોસ પ્રતિકૃતિ

હું PostgreSQL અને MySQL વચ્ચે ક્રોસ-રિપ્લિકેશન તેમજ બે ડેટાબેઝ સર્વર્સ વચ્ચે ક્રોસ-રિપ્લિકેશન સેટ કરવા માટેની પદ્ધતિઓની રૂપરેખા આપીશ. સામાન્ય રીતે, ક્રોસ-રિપ્લિકેટેડ ડેટાબેસેસને સજાતીય કહેવામાં આવે છે, અને તે એક RDBMS સર્વરથી બીજામાં ખસેડવાની અનુકૂળ પદ્ધતિ છે.

PostgreSQL અને MySQL ડેટાબેઝને સામાન્ય રીતે રિલેશનલ ગણવામાં આવે છે, પરંતુ વધારાના એક્સ્ટેન્શન્સ સાથે તેઓ NoSQL ક્ષમતાઓ પ્રદાન કરે છે. અહી આપણે પોસ્ટગ્રેએસક્યુએલ અને માયએસક્યુએલ વચ્ચે રીલેશનલ ડીબીએમએસ પરિપ્રેક્ષ્યમાં પ્રતિકૃતિની ચર્ચા કરીશું.

અમે સમગ્ર આંતરિક કાર્યનું વર્ણન કરીશું નહીં, ફક્ત મૂળભૂત સિદ્ધાંતોનું વર્ણન કરીશું જેથી કરીને તમને ડેટાબેઝ સર્વર્સ, ફાયદા, મર્યાદાઓ અને ઉપયોગના કિસ્સાઓ વચ્ચે પ્રતિકૃતિ ગોઠવવાનો ખ્યાલ આવે.

સામાન્ય રીતે, બે સરખા ડેટાબેઝ સર્વર વચ્ચેની પ્રતિકૃતિ કાં તો બાઈનરી મોડમાં અથવા માસ્ટર (ઉર્ફે પ્રકાશક, માસ્ટર અથવા સક્રિય) અને ગુલામ (સબ્સ્ક્રાઇબર, સ્ટેન્ડબાય અથવા નિષ્ક્રિય) વચ્ચેની ક્વેરીનો ઉપયોગ કરીને કરવામાં આવે છે. પ્રતિકૃતિનો હેતુ સ્લેવ બાજુ પર માસ્ટર ડેટાબેઝની રીઅલ-ટાઇમ નકલ પ્રદાન કરવાનો છે. આ કિસ્સામાં, ડેટા માસ્ટરથી સ્લેવમાં સ્થાનાંતરિત થાય છે, એટલે કે, સક્રિયથી નિષ્ક્રિયમાં, કારણ કે પ્રતિકૃતિ ફક્ત એક જ દિશામાં કરવામાં આવે છે. પરંતુ તમે બંને દિશામાં બે ડેટાબેઝ વચ્ચે પ્રતિકૃતિ સેટ કરી શકો છો, જેથી ડેટા સક્રિય-સક્રિય ગોઠવણીમાં સ્લેવમાંથી માસ્ટરમાં ટ્રાન્સફર થાય. આ બધું, કેસ્કેડીંગ પ્રતિકૃતિ સહિત, બે અથવા વધુ સમાન ડેટાબેઝ સર્વર્સ વચ્ચે શક્ય છે. સક્રિય-સક્રિય અથવા સક્રિય-નિષ્ક્રિય ગોઠવણી જરૂરિયાત, પ્રારંભિક ગોઠવણીમાં આવી ક્ષમતાઓની ઉપલબ્ધતા અથવા બાહ્ય રૂપરેખાંકન સોલ્યુશન્સ અને હાલના ટ્રેડ-ઓફના ઉપયોગ પર આધારિત છે.

વર્ણવેલ રૂપરેખાંકન વિવિધ ડેટાબેઝ સર્વર્સ વચ્ચે શક્ય છે. સર્વરને બીજા ડેટાબેઝ સર્વરમાંથી નકલ કરાયેલ ડેટા સ્વીકારવા માટે ગોઠવી શકાય છે અને હજુ પણ નકલ કરાયેલ ડેટાના રીઅલ-ટાઇમ સ્નેપશોટ જાળવી શકે છે. MySQL અને PostgreSQL આમાંની મોટાભાગની રૂપરેખાંકનો ઇન-હાઉસ અથવા તૃતીય-પક્ષ એક્સ્ટેંશન દ્વારા ઓફર કરે છે, જેમાં બાઈનરી લોગ પદ્ધતિઓ, ડિસ્ક લોકીંગ અને સ્ટેટમેન્ટ- અને રો-આધારિત પદ્ધતિઓનો સમાવેશ થાય છે.

MySQL અને PostgreSQL વચ્ચેની ક્રોસ પ્રતિકૃતિ એક ડેટાબેઝ સર્વરથી બીજામાં એક વખતના સ્થળાંતર માટે જરૂરી છે. આ ડેટાબેઝ વિવિધ પ્રોટોકોલનો ઉપયોગ કરે છે, તેથી તેમને સીધું લિંક કરવું શક્ય નથી. ડેટા એક્સચેન્જ સ્થાપિત કરવા માટે, તમે બાહ્ય ઓપન સોર્સ ટૂલનો ઉપયોગ કરી શકો છો, ઉદાહરણ તરીકે pg_chameleon.

pg_chameleon શું છે

pg_chameleon એ પાયથોન 3 માં MySQL થી PostgreSQL સુધીની પ્રતિકૃતિ સિસ્ટમ છે. તે ઓપન સોર્સ mysql-રિપ્લિકેશન લાઇબ્રેરીનો ઉપયોગ કરે છે, પાયથોનમાં પણ. પંક્તિની છબીઓ MySQL કોષ્ટકોમાંથી કાઢવામાં આવે છે અને PostgreSQL ડેટાબેઝમાં JSONB ઑબ્જેક્ટ તરીકે સંગ્રહિત થાય છે, અને પછી pl/pgsql ફંક્શન દ્વારા ડિક્રિપ્ટ કરવામાં આવે છે અને PostgreSQL ડેટાબેઝમાં પુનઃઉત્પાદિત થાય છે.

pg_chameleon ની વિશેષતાઓ

એક જ ક્લસ્ટરમાંથી બહુવિધ MySQL સ્કીમા એક-થી-ઘણી રૂપરેખાંકનમાં એક લક્ષ્ય પોસ્ટગ્રેએસક્યુએલ ડેટાબેઝમાં નકલ કરી શકાય છે.
સ્ત્રોત અને લક્ષ્ય સ્કીમા નામો સમાન હોઈ શકતા નથી.
પ્રતિકૃતિ ડેટા કાસ્કેડેડ MySQL પ્રતિકૃતિમાંથી મેળવી શકાય છે.
કોષ્ટકો કે જે નકલ કરી શકતા નથી અથવા ભૂલો ઉત્પન્ન કરી શકતા નથી તે બાકાત છે.
દરેક પ્રતિકૃતિ કાર્ય ડિમન દ્વારા નિયંત્રિત થાય છે.
YAML-આધારિત પરિમાણો અને રૂપરેખાંકન ફાઇલો દ્વારા નિયંત્રણ.

ઉદાહરણ:

હોસ્ટ
વીએમ 1
વીએમ 2

OS સંસ્કરણ
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64

ડીબી સર્વર સંસ્કરણ
માયએસક્યુએલ 5.7.26
PostgreSQL 10.5

ડીબી પોર્ટ
3306
5433

આઇપી સરનામું
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) ને બુલિયન મૂલ્યમાં રૂપાંતરિત કરે છે. આગળના વિભાગમાં, અમે લક્ષ્ય ડેટાબેઝ સાથે જોડાણ વિગતોનો ઉલ્લેખ કરીએ છીએ. અમારા કિસ્સામાં, આ પોસ્ટગ્રેએસક્યુએલ ડેટાબેઝ છે, નિયુક્ત pg_conn. છેલ્લા વિભાગમાં, અમે સ્રોત ડેટા સૂચવીએ છીએ, એટલે કે, સ્રોત ડેટાબેઝના કનેક્શન પરિમાણો, સ્રોત અને લક્ષ્ય ડેટાબેસેસ વચ્ચેની મેપિંગ યોજના, કોષ્ટકો કે જેને છોડવાની જરૂર છે, રાહ જોવાનો સમય, મેમરી, પેકેજ કદ. નોંધ કરો કે "સ્રોતો" બહુવચન છે, જેનો અર્થ થાય છે કે આપણે એક થી વધુ રૂપરેખાંકન સેટ કરવા માટે એક લક્ષ્ય ડેટાબેઝમાં બહુવિધ સ્ત્રોત ડેટાબેસેસ ઉમેરી શકીએ છીએ.

ઉદાહરણ ડેટાબેઝ world_x માં પંક્તિઓ સાથે 4 કોષ્ટકો છે જે MySQL સમુદાય ઉદાહરણો તરીકે પ્રદાન કરે છે. તે ડાઉનલોડ કરી શકાય છે અહીં. નમૂના ડેટાબેઝ ટાર અને સંકુચિત આર્કાઇવ તરીકે પંક્તિઓ બનાવવા અને આયાત કરવા માટેની સૂચનાઓ સાથે આવે છે.

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 ડેટાબેઝમાંથી ફેરફારો સ્વીકારશે. 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 દલીલ પોસ્ટગ્રેએસક્યુએલ ડેટાબેઝમાં ડિફોલ્ટ સ્કીમા (sch_chameleon) અને પ્રતિકૃતિ સ્કીમા (pgworld_x) બનાવે છે, જેમ કે આપણે પહેલાથી જ ચર્ચા કરી છે. એડ_સોર્સ દલીલ રૂપરેખાંકન ફાઇલ (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 ડેટાબેઝમાં કેટલાક રેકોર્ડ દાખલ કરીએ છીએ, અને ડિમનને અપડેટ કરવા માટે pg_chameleon માં sync_tables દલીલને કૉલ કરીએ છીએ અને 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 આદેશો તેનો અંત હશે. બધા લક્ષ્ય કોષ્ટકોની પંક્તિઓ નકલ કરવામાં આવી છે તેની ખાતરી કર્યા પછી આદેશોને અમલમાં મૂકવાની જરૂર છે, અને પરિણામ સ્ત્રોત ડેટાબેઝ અથવા પ્રતિકૃતિ યોજના (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 ડેટાબેઝમાંથી ડેટાને એક પોસ્ટગ્રેએસક્યુએલ ડેટાબેઝમાં જોડી રહ્યાં હોવ તો આ ખૂબ જ ઉપયોગી છે.
તમારે પસંદ કરેલા કોષ્ટકોની નકલ કરવાની જરૂર નથી.

pg_chameleon ના ગેરફાયદા

માત્ર MySQL 5.5 અને તેનાથી ઉપરના સ્ત્રોત તરીકે અને PostgreSQL 9.5 અને તેનાથી ઉપરના લક્ષ્ય ડેટાબેઝ તરીકે સપોર્ટેડ છે.
દરેક કોષ્ટકમાં પ્રાથમિક અથવા અનન્ય કી હોવી આવશ્યક છે, અન્યથા કોષ્ટકો init_replica પ્રક્રિયા દરમિયાન આરંભ કરવામાં આવે છે પરંતુ તેની નકલ કરવામાં આવતી નથી.
વન-વે પ્રતિકૃતિ - માત્ર MySQL થી PostgreSQL સુધી. તેથી, તે ફક્ત "સક્રિય-નિષ્ક્રિય" સર્કિટ માટે યોગ્ય છે.
સ્ત્રોત માત્ર MySQL ડેટાબેઝ હોઈ શકે છે, અને સ્ત્રોત તરીકે PostgreSQL ડેટાબેઝ માટે સમર્થન માત્ર પ્રાયોગિક અને મર્યાદાઓ સાથે છે (વધુ જાણો અહીં)

pg_chameleon માટે પરિણામો

ડેટાબેઝને MySQL થી PostgreSQL માં સ્થાનાંતરિત કરવા માટે pg_chameleon માં પ્રતિકૃતિ પદ્ધતિ ઉત્તમ છે. નોંધપાત્ર નુકસાન એ છે કે પ્રતિકૃતિ ફક્ત એક-માર્ગી છે, તેથી ડેટાબેઝ વ્યાવસાયિકો સ્થળાંતર સિવાય અન્ય કોઈપણ વસ્તુ માટે તેનો ઉપયોગ કરવા માંગતા હોય તેવી શક્યતા નથી. પરંતુ વન-વે પ્રતિકૃતિની સમસ્યા અન્ય ઓપન સોર્સ ટૂલ - SymmetricDS સાથે ઉકેલી શકાય છે.

સત્તાવાર દસ્તાવેજોમાં વધુ વાંચો અહીં. કમાન્ડ લાઇન મદદ મળી શકે છે અહીં.

SymmetricDS ની ઝાંખી

SymmetricDS એ એક ઓપન સોર્સ ટૂલ છે જે કોઈપણ ડેટાબેઝને કોઈપણ અન્ય સામાન્ય ડેટાબેઝમાં નકલ કરે છે: Oracle, MongoDB, PostgreSQL, MySQL, SQL સર્વર, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird અને અન્ય ક્લાઉડ ડેટાબેઝ ઉદાહરણો, દા.ત. અને Redshift, એઝ્યુર, વગેરે ઉપલબ્ધ સુવિધાઓ: ડેટાબેઝ અને ફાઇલ સિંક્રોનાઇઝેશન, મલ્ટિ-માસ્ટર ડેટાબેઝ પ્રતિકૃતિ, ફિલ્ટર સિંક્રોનાઇઝેશન, ટ્રાન્સફોર્મેશન અને અન્ય. આ જાવા ટૂલ છે અને તેને JRE અથવા JDK (સંસ્કરણ 8.0 અથવા ઉચ્ચતર) નું પ્રમાણભૂત પ્રકાશન જરૂરી છે. અહીં, સ્રોત ડેટાબેઝમાં ટ્રિગર્સમાં ડેટા ફેરફારો રેકોર્ડ કરી શકાય છે અને બેચના રૂપમાં યોગ્ય લક્ષ્ય ડેટાબેઝને મોકલી શકાય છે.

SymmetricDS લક્ષણો

ટૂલ પ્લેટફોર્મ સ્વતંત્ર છે, એટલે કે બે કે તેથી વધુ અલગ અલગ ડેટાબેઝ ડેટાનું વિનિમય કરી શકે છે.
રિલેશનલ ડેટાબેઝ ડેટા ચેન્જ રેકોર્ડનો ઉપયોગ કરીને સિંક્રનાઇઝ થાય છે, જ્યારે ફાઇલ સિસ્ટમ-આધારિત ડેટાબેઝ ફાઇલ સિંક્રોનાઇઝેશનનો ઉપયોગ કરે છે.
નિયમોના સમૂહના આધારે પુશ અને પુલ પદ્ધતિઓનો ઉપયોગ કરીને દ્વિ-માર્ગી પ્રતિકૃતિ.
સુરક્ષિત અને ઓછી બેન્ડવિડ્થ નેટવર્ક્સ પર ડેટા ટ્રાન્સફર શક્ય છે.
જ્યારે નોડ્સ નિષ્ફળતા અને સ્વચાલિત સંઘર્ષ રિઝોલ્યુશન પછી ફરીથી કામગીરી શરૂ કરે છે ત્યારે સ્વચાલિત પુનઃપ્રાપ્તિ.
ક્લાઉડ સુસંગત અને શક્તિશાળી એક્સ્ટેંશન API.

ઉદાહરણ:

SymmetricDS બેમાંથી એક રીતે ગોઠવી શકાય છે:
એક મુખ્ય (પિતૃ) નોડ કે જે બે સ્લેવ (બાળક) નોડ્સ વચ્ચે ડેટા પ્રતિકૃતિનું કેન્દ્રિય રીતે સંકલન કરે છે અને બાળ ગાંઠો વચ્ચે સંચાર ફક્ત માતાપિતા દ્વારા જ થાય છે.
સક્રિય નોડ (નોડ 1) મધ્યસ્થી વિના બીજા સક્રિય નોડ (નોડ 2) સાથે નકલ માટે વાતચીત કરી શકે છે.

બંને વિકલ્પોમાં, પુશ અને પુલનો ઉપયોગ કરીને ડેટા વિનિમય થાય છે. આ ઉદાહરણમાં આપણે સક્રિય-સક્રિય ગોઠવણીને ધ્યાનમાં લઈશું. સમગ્ર આર્કિટેક્ચરનું વર્ણન કરવામાં ઘણો સમય લાગશે, તેથી તમારું સંશોધન કરો. નેતૃત્વSymmetricDS ઉપકરણ વિશે વધુ જાણવા માટે.

SymmetricDS ઇન્સ્ટોલ કરવું ખૂબ જ સરળ છે: zip ફાઇલનું ઓપન સોર્સ વર્ઝન ડાઉનલોડ કરો અહીંથી અને તમે ઇચ્છો ત્યાં તેને બહાર કાઢો. નીચે આપેલ કોષ્ટક આ ઉદાહરણમાં SymmetricDS ના સ્થાપન સ્થાન અને સંસ્કરણ, તેમજ ડેટાબેઝ આવૃત્તિઓ, Linux આવૃત્તિઓ, IP સરનામાંઓ અને બંને નોડ્સ માટેના પોર્ટ વિશે માહિતી પ્રદાન કરે છે.

હોસ્ટ
વીએમ 1
વીએમ 2

OS સંસ્કરણ
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64

ડીબી સર્વર સંસ્કરણ
માયએસક્યુએલ 5.7.26
PostgreSQL 10.5

ડીબી પોર્ટ
3306
5832

આઇપી સરનામું
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

SymmetricDS નોડ નામ
કોર્પ-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 પોસ્ટગ્રેએસક્યુએલ ડેટાબેઝ ચલાવે છે અને pgdb_replica એ પ્રતિકૃતિ ડેટાબેઝ છે. registration.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

ઉદાહરણમાં, આઇટમ અને આઇટમ_સેલિંગ_કિંમત કોષ્ટકો corp-000 થી સ્ટોર-001 સુધી નકલ કરવા માટે આપમેળે ગોઠવવામાં આવે છે, અને વેચાણ કોષ્ટકો (sale_transaction અને sale_return_line_item) સ્ટોર-001 થી corp-000 માં નકલ કરવા માટે આપમેળે ગોઠવવામાં આવે છે. હવે અમે હોસ્ટ vm2 (store-001) પર PostgreSQL ડેટાબેઝમાં એક સ્કીમા બનાવીએ છીએ જેથી તેને corp-000માંથી ડેટા પ્રાપ્ત કરવા માટે તૈયાર કરી શકાય.

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 &

લોગ એન્ટ્રીઓ બેકગ્રાઉન્ડ લોગ ફાઈલ (symmetric.log) ને ડાયરેક્ટરીમાં લોગ ફોલ્ડરમાં મોકલવામાં આવે છે જ્યાં SymmetricDS ઇન્સ્ટોલ કરેલ છે, તેમજ પ્રમાણભૂત આઉટપુટ પર. સિમ સર્વર હવે નોડ સ્ટોર-001 પર શરૂ કરી શકાય છે.

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

જો તમે vm2 હોસ્ટ પર sym સર્વર પ્રક્રિયા ચલાવો છો, તો તે PostgreSQL ડેટાબેઝમાં SymmetricDS કેટલોગ કોષ્ટકો પણ બનાવશે. જો તમે બંને નોડ્સ પર સિમ સર્વર પ્રક્રિયા ચલાવો છો, તો તેઓ કોર્પ-000 થી સ્ટોર-001 સુધીના ડેટાની નકલ કરવા માટે એકબીજા સાથે સંકલન કરે છે. જો થોડીક સેકન્ડો પછી આપણે બંને બાજુના તમામ 4 કોષ્ટકોને ક્વેરી કરીએ, તો આપણે જોશું કે પ્રતિકૃતિ સફળ હતી. અથવા તમે નીચેના આદેશ સાથે corp-001 માંથી નોડ સ્ટોર-000 પર બુટસ્ટ્રેપ મોકલી શકો છો.

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

આ સમયે, નોડ કોર્પ-000 (હોસ્ટ: vm1) પર MySQL ડેટાબેઝમાં આઇટમ ટેબલમાં એક નવો રેકોર્ડ દાખલ કરવામાં આવે છે, અને તમે નોડ સ્ટોર-001 (હોસ્ટ: vm2) પર પોસ્ટગ્રેએસક્યુએલ ડેટાબેઝમાં તેની પ્રતિકૃતિ તપાસી શકો છો. અમે ડેટાને કોર્પ-000 થી સ્ટોર-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 થી કોર્પ-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)

પછી રૂપરેખાંકનને સ્કીમા ફેરફારની સૂચના આપવામાં આવે છે, એટલે કે, સિંક-ટ્રિગર્સ દલીલ સાથે symadmin આદેશનો ઉપયોગ કરીને, એક નવું ટેબલ ઉમેરવું, જે ટેબલ વ્યાખ્યાઓને મેપ કરવા માટે ટ્રિગર્સને ફરીથી બનાવે છે. નોડ સ્ટોર-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 સ્ટેટમેન્ટ બનાવવા માટે સ્ક્રિપ્ટનો ઉપયોગ કરો છો જે પ્રતિકૃતિના નિયમો અને દિશાને વ્યાખ્યાયિત કરે છે.
લોગમાં ઘણી બધી માહિતી રેકોર્ડ કરવામાં આવી રહી છે, અને કેટલીકવાર તમારે લોગ ફાઇલને વ્યવસ્થિત કરવાની જરૂર પડે છે જેથી તે વધુ જગ્યા ન લે.

SymmetricDS માટે પરિણામો

SymmetricDS તમને ફાઇલોની નકલ અને સિંક્રનાઇઝ કરવા માટે બે, ત્રણ અથવા તો કેટલાક હજાર નોડ્સ વચ્ચે દ્વિ-માર્ગી પ્રતિકૃતિ સેટ કરવાની મંજૂરી આપે છે. આ એક અનન્ય સાધન છે જે સ્વતંત્ર રીતે ઘણા કાર્યો કરે છે, જેમ કે નોડ પર લાંબા સમય સુધી ડાઉનટાઇમ પછી સ્વચાલિત ડેટા પુનઃપ્રાપ્તિ, HTTPS દ્વારા નોડ્સ વચ્ચે સુરક્ષિત અને કાર્યક્ષમ ડેટા વિનિમય, નિયમોના સમૂહના આધારે સ્વચાલિત સંઘર્ષ સંચાલન વગેરે. SymmetricDS કરે છે. કોઈપણ ડેટાબેઝ વચ્ચે પ્રતિકૃતિ, તેથી, તેનો ઉપયોગ વિવિધ પ્રકારના દૃશ્યો માટે થઈ શકે છે, જેમાં સ્થળાંતર, સ્થળાંતર, વિતરણ, ફિલ્ટરિંગ અને સમગ્ર પ્લેટફોર્મ પર ડેટાના રૂપાંતરણનો સમાવેશ થાય છે.

ઉદાહરણ અધિકારી પર આધારિત છે ઝડપી માર્ગદર્શિકા SymmetricDS દ્વારા. IN વપરાશકર્તા માર્ગદર્શિકા SymmetricDS સાથે પ્રતિકૃતિ ગોઠવવામાં સામેલ વિવિધ ખ્યાલોનું વિગતવાર વર્ણન કરે છે.

સોર્સ: www.habr.com