שכפול צולב בין 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-replication, גם ב-Python. תמונות שורות מחולצות מטבלאות MySQL ומאוחסנות כאובייקטי JSONB במסד הנתונים של PostgreSQL, ולאחר מכן מפוענחות על ידי הפונקציה pl/pgsql ומשוכפלים במסד הנתונים PostgreSQL.

תכונות של pg_chameleon

ניתן לשכפל סכימות MySQL מרובות מאותו אשכול למסד נתונים PostgreSQL יעד יחיד בתצורה של אחד לרבים
שמות סכימת המקור והיעד אינם יכולים להיות זהים.
ניתן לאחזר נתוני שכפול מעתק של MySQL מדורג.
טבלאות שאינן יכולות לשכפל או לייצר שגיאות אינן נכללות.
כל פונקציית שכפול נשלטת על ידי דמונים.
שליטה באמצעות פרמטרים וקבצי תצורה מבוססי YAML.

דוגמה

מארח
Vm1
Vm2

גרסת מערכת ההפעלה
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 (chameleon היא פקודה) עם הארגומנט set_configuration_files כדי להפעיל את pg_chameleon וליצור ספריות ברירת מחדל וקובצי תצורה.

(venv) $> chameleon set_configuration_files
creating directory /root/.pg_chameleon
creating directory /root/.pg_chameleon/configuration/
creating directory /root/.pg_chameleon/logs/
creating directory /root/.pg_chameleon/pid/
copying configuration  example in /root/.pg_chameleon/configuration//config-example.yml

כעת אנו יוצרים עותק של config-example.yml בתור default.yml כך שהוא יהפוך לקובץ תצורת ברירת המחדל. קובץ תצורה לדוגמה עבור דוגמה זו מסופק להלן.

$> cat default.yml
---
#global settings
pid_dir: '~/.pg_chameleon/pid/'
log_dir: '~/.pg_chameleon/logs/'
log_dest: file
log_level: info
log_days_keep: 10
rollbar_key: ''
rollbar_env: ''

# type_override allows the user to override the default type conversion into a different one.
type_override:
  "tinyint(1)":
    override_to: boolean
    override_tables:
      - "*"

#postgres  destination connection
pg_conn:
  host: "192.168.56.106"
  port: "5433"
  user: "usr_replica"
  password: "pass123"
  database: "db_replica"
  charset: "utf8"

sources:
  mysql:
    db_conn:
      host: "192.168.56.102"
      port: "3306"
      user: "usr_replica"
      password: "pass123"
      charset: 'utf8'
      connect_timeout: 10
    schema_mappings:
      world_x: pgworld_x
    limit_tables:
#      - delphis_mediterranea.foo
    skip_tables:
#      - delphis_mediterranea.bar
    grant_select_to:
      - usr_readonly
    lock_timeout: "120s"
    my_server_id: 100
    replica_batch_size: 10000
    replay_max_rows: 10000
    batch_retention: '1 day'
    copy_max_memory: "300M"
    copy_mode: 'file'
    out_dir: /tmp
    sleep_loop: 1
    on_error_replay: continue
    on_error_read: continue
    auto_maintenance: "disabled"
    gtid_enable: No
    type: mysql
    skip_events:
      insert:
        - delphis_mediterranea.foo #skips inserts on the table delphis_mediterranea.foo
      delete:
        - delphis_mediterranea #skips deletes on schema delphis_mediterranea
      update:

קובץ התצורה בדוגמה זו הוא קובץ pg_chameleon לדוגמה עם שינויים קלים כדי להתאים לסביבות המקור והיעד, ולהלן סקירה כללית של החלקים השונים של קובץ התצורה.

בקובץ התצורה default.yml ישנו קטע של הגדרות גלובליות, שבו ניתן לנהל הגדרות כמו מיקום קובץ הנעילה, מיקום היומנים, תקופת האחסון של יומנים וכו'. לאחר מכן מגיע סעיף דריסת הסוג, שבו קבוצה של כללים לעקוף טיפוסים במהלך שכפול. הדוגמה כברירת מחדל לכלל עוקף סוג הממיר את tinyint(1) לערך בוליאני. בסעיף הבא, אנו מציינים את פרטי החיבור למסד הנתונים היעד. במקרה שלנו, זהו מסד נתונים PostgreSQL, המכונה pg_conn. בסעיף האחרון, אנו מציינים את נתוני המקור, כלומר, פרמטרי החיבור של מסד הנתונים של המקור, סכימת המיפוי בין מסדי הנתונים של המקור למטרה, טבלאות שיש לדלג עליהן, זמן המתנה, זיכרון, גודל חבילה. שים לב ש"מקורות" הוא רבים, כלומר אנו יכולים להוסיף מסדי נתונים מרובים של מקורות למסד נתונים יעד יחיד כדי להגדיר תצורה של רבים לאחד.

מסד הנתונים לדוגמה world_x מכיל 4 טבלאות עם שורות שקהילת MySQL מציעה כדוגמאות. ניתן להוריד אותו כאן. מסד הנתונים לדוגמה מגיע כזפת וארכיון דחוס עם הוראות ליצירה וייבוא ​​של שורות.

במסדי נתונים 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 באחת משתי דרכים:
צומת מאסטר (הורה) שמתאם באופן מרכזי את שכפול הנתונים בין שני צמתים עבדים (ילדים), ותקשורת בין צמתי צאצא מתרחשת רק דרך האב.
צומת פעיל (צומת 1) יכול לתקשר לצורך שכפול עם צומת פעיל אחר (צומת 2) ללא מתווך.

בשתי האפשרויות, חילופי נתונים מתרחשים באמצעות Push ו-Pull. בדוגמה זו נשקול תצורה אקטיבית-אקטיבית. זה ייקח יותר מדי זמן לתאר את הארכיטקטורה כולה, אז בצע את המחקר שלך. מַנהִיגוּתלמידע נוסף על התקן SymmetricDS.

התקנת SymmetricDS היא פשוטה מאוד: הורד את גרסת הקוד הפתוח של קובץ ה-zip מכאן ולהוציא אותו לאן שתרצה. הטבלה שלהלן מספקת מידע על מיקום ההתקנה והגרסה של SymmetricDS בדוגמה זו, כמו גם את גרסאות מסד הנתונים, גרסאות לינוקס, כתובות IP ויציאות עבור שני הצמתים.

מארח
Vm1
Vm2

גרסת מערכת ההפעלה
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
corp-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 הוא מסד הנתונים של השכפול. 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 מכילה פרמטרים להגדרת שכפול דו-כיווני בין שני שרתי מסד נתונים (שני צמתים). השלבים שלהלן מבוצעים על host vm1 (corp-000), אשר יצור סכמה לדוגמה עם 4 טבלאות. לאחר מכן הפעלת create-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

בדוגמה, טבלאות הפריט והפריט_selling_price מוגדרות אוטומטית לשכפול מ-corp-000 ל-store-001, וטבלאות המכירה (sale_transaction ו-sale_return_line_item) מוגדרות אוטומטית לשכפול מ-store-001 ל-corp-000. כעת אנו יוצרים סכימה במסד הנתונים PostgreSQL במארח vm2 (store-001) כדי להכין אותו לקבל נתונים מ-corp-000.

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

הקפד לבדוק שבבסיס הנתונים של MySQL ב-vm1 יש טבלאות לדוגמה וטבלאות קטלוג SymmetricDS. שימו לב שטבלאות המערכת של SymmetricDS (עם קידומת sym_) זמינות כרגע רק ב-node corp-000 מכיוון ששם הרצנו את הפקודה create-sym-tables וננהל את השכפול. ובבסיס הנתונים על node store-001 יהיו רק 4 טבלאות לדוגמה ללא נתונים.

את כל. הסביבה מוכנה להריץ תהליכי שרת סימנים בשני הצמתים כפי שמוצג להלן.

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. אם לאחר מספר שניות נבצע שאילתה בכל 4 הטבלאות משני הצדדים, נראה שהשכפול הצליח. או שאתה יכול לשלוח את ה-bootstrap ל-node store-001 מ-corp-000 עם הפקודה הבאה.

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