การจำลองแบบ- เทคนิคที่ใช้ในสถาปัตยกรรมของระบบที่ทำงานภายใต้โหลด ซึ่งผลลัพธ์คือการกระจายโหลดเมื่อทำงานกับฐานข้อมูลเดียวผ่านเซิร์ฟเวอร์หลายเครื่อง การจำลองแบบ MySQL MASTER SLAVE ถูกใช้บ่อยกว่า แต่ก็มีการใช้การจำลองแบบประเภทที่สองเช่นกัน - Master-Master

การจำลองแบบ MySQL MASTER SLAVE คืออะไร และใช้เพื่ออะไร

การจำลองแบบ มาสเตอร์-สเลฟเกี่ยวข้องกับการทำซ้ำข้อมูลไปยังเซิร์ฟเวอร์ MySQL ทาส การทำสำเนาดังกล่าวส่วนใหญ่ทำเพื่อให้มั่นใจในความน่าเชื่อถือ หากเซิร์ฟเวอร์หลักล้มเหลว ฟังก์ชั่นจะถูกสลับไปที่ทาส

การจำลองแบบยังสามารถดำเนินการเพื่อปรับปรุงประสิทธิภาพของระบบได้ แต่ประสิทธิภาพมักเป็นเรื่องรองเสมอ
เมื่อแอปพลิเคชันทำงานกับฐานข้อมูล การดำเนินการที่พบบ่อยที่สุดคือ เลือก- การขออ่านข้อมูล แก้ไขข้อมูล - การร้องขอ ลบ, แทรก, อัปเดต, เปลี่ยนแปลงตามสถิติแล้วมันเกิดขึ้นน้อยกว่ามาก

เพื่อป้องกันข้อมูลสูญหายหากเซิร์ฟเวอร์ตัวใดตัวหนึ่งล้มเหลว การดำเนินการเพื่อเปลี่ยนแปลงข้อมูลในตารางจะถูกประมวลผลโดยเซิร์ฟเวอร์หลักเสมอ การเปลี่ยนแปลงจะถูกจำลองแบบไปยัง Slave การอ่านสามารถทำได้จากเซิร์ฟเวอร์ที่มีบทบาทเป็นทาส
ด้วยเหตุนี้ คุณจึงสามารถได้รับประสิทธิภาพเพิ่มขึ้นพร้อมกับความน่าเชื่อถือ

โซลูชันนี้ได้รับความนิยม แต่อาจไม่สามารถใช้ได้เสมอไป เนื่องจากอาจมีความล่าช้าในระหว่างการจำลองแบบ - หากเกิดเหตุการณ์นี้ขึ้น จะต้องอ่านข้อมูลจากเซิร์ฟเวอร์หลักด้วย

การส่งคำขอบางประเภทไปยังเซิร์ฟเวอร์ฐานข้อมูลเฉพาะนั้นไม่ว่าในกรณีใดก็ตามจะถูกนำไปใช้ในระดับแอปพลิเคชัน

หากคุณแยกคำสั่ง SELECT และคำสั่งอื่นๆ ทั้งหมดในระดับโปรแกรมโดยส่งไปที่ เซิร์ฟเวอร์ที่จำเป็นหากหนึ่งในนั้นล้มเหลว แอปพลิเคชันที่โครงสร้างพื้นฐานให้บริการจะไม่สามารถใช้งานได้ เพื่อให้ได้ผล คุณต้องจัดหาข้อมูลเพิ่มเติม วงจรที่ซับซ้อนและจองเซิร์ฟเวอร์แต่ละเครื่อง

การจำลองมีไว้เพื่อความทนทานต่อข้อผิดพลาด ไม่ใช่เพื่อการปรับขนาด

การจำลองแบบ MySQL MASTER SLAVE - การตั้งค่าบน Debian

เราจะใช้เซิร์ฟเวอร์สองเครื่องพร้อมที่อยู่:

• เซิร์ฟเวอร์หลัก 192.168.0.1
• เซิร์ฟเวอร์ทาส 192.168.0.2

สำหรับการสาธิต จะใช้ VDS ที่เชื่อมต่อกับเครือข่ายท้องถิ่น
เพื่อให้ทราบอยู่เสมอว่าเซิร์ฟเวอร์ใดที่เรากำลังดำเนินการคำสั่งนี้ เราจะแก้ไขไฟล์ /etc/hosts บนเซิร์ฟเวอร์ทั้งสองเครื่อง

192.168.0.1 ต้นแบบ

192.168.0.2 ทาส

มาแทนที่ค่าที่มีอยู่ใน /etc/hostname ด้วย master และทาส ตามลำดับ เพื่อให้การเปลี่ยนแปลงมีผลและรีบูตเซิร์ฟเวอร์

1. เราทำการตั้งค่าบนเซิร์ฟเวอร์หลัก

รูต@มาสเตอร์:/#

แก้ไขหลักครับ ไฟล์การกำหนดค่าเซิร์ฟเวอร์ฐานข้อมูล

mcedit /etc/mysql/my.cnf

เลือกรหัสเซิร์ฟเวอร์ - คุณสามารถระบุหมายเลขใดก็ได้ โดยค่าเริ่มต้นคือ 1 - เพียงไม่ใส่เครื่องหมายข้อคิดเห็นบรรทัด

เซิร์ฟเวอร์-id = 1

กำหนดเส้นทางไปยังบันทึกไบนารี - ระบุเป็นค่าเริ่มต้นด้วย ไม่ต้องใส่เครื่องหมายข้อคิดเห็น

ตั้งชื่อฐานข้อมูลที่เราจะจำลองไปยังเซิร์ฟเวอร์อื่น

binlog_do_db = db1

รีสตาร์ท Mysql เพื่อให้อ่านไฟล์การกำหนดค่าอีกครั้งและการเปลี่ยนแปลงจะมีผล:

/etc/init.d/mysql รีสตาร์ท

2. กำหนดสิทธิ์ที่จำเป็นของผู้ใช้

ไปที่คอนโซลเซิร์ฟเวอร์ฐานข้อมูล:

เราให้สิทธิ์ที่จำเป็นแก่ผู้ใช้บนเซิร์ฟเวอร์ทาส:

ให้สิทธิ์การจำลองแบบ SLAVE บน *.* ถึง "slave_user"@"%" ระบุโดย "123";

การล็อคตารางทั้งหมดในฐานข้อมูล

ล้างตารางพร้อมล็อคการอ่าน;

การตรวจสอบสถานะของเซิร์ฟเวอร์หลัก:

+——————+———-+—————+——————+
- ไฟล์ | ตำแหน่ง | Binlog_Do_DB | Binlog_Ignore_DB |
+——————+———-+—————+——————+
- mysql-bin.000001 | 327 | db1 | -
+——————+———-+—————+——————+
1 แถวในชุด (0.00 วินาที)

3. สร้างดัมพ์ฐานข้อมูลบนเซิร์ฟเวอร์

สร้างดัมพ์ฐานข้อมูล:

mysqldump -u root -p db1 > db1.sql

ปลดล็อคตารางในคอนโซล mysql:

4. ถ่ายโอนดัมพ์ฐานข้อมูลไปยังเซิร์ฟเวอร์ Slave

เอสซีพี db1.sql [ป้องกันอีเมล]:/บ้าน

เราดำเนินการเพิ่มเติมบนเซิร์ฟเวอร์ Slave

รูต@ทาส:/#

5. การสร้างฐานข้อมูล

กำลังโหลดดัมพ์:

mysql -u รูท -p db1< db1.sql

6. ทำการเปลี่ยนแปลง my.cnf

mcedit /etc/mysql/my.cnf

เรากำหนด ID โดยเพิ่มค่าที่ตั้งไว้บนเซิร์ฟเวอร์หลัก

เซิร์ฟเวอร์-id = 2

กำหนดเส้นทางไปยังบันทึกการถ่ายทอด

รีเลย์-log = /var/log/mysql/mysql-relay-bin.log

และเส้นทางไปยังบันทึกถังขยะบนเซิร์ฟเวอร์หลัก

log_bin = /var/log/mysql/mysql-bin.log

ระบุฐาน

binlog_do_db = db1

เริ่มบริการใหม่

/etc/init.d/mysql รีสตาร์ท

7. ตั้งค่าการเชื่อมต่อกับเซิร์ฟเวอร์หลัก

เปลี่ยน MASTER เป็น MASTER_HOST="192.168.0.1", MASTER_USER="slave_user", MASTER_PASSWORD="123", MASTER_LOG_FILE = "mysql-bin.000001", MASTER_LOG_POS = 327;

เราเริ่มการจำลองแบบบนเซิร์ฟเวอร์ทาส:

คุณสามารถตรวจสอบการดำเนินการเรพลิเคชันบน Slave ได้ตามคำขอต่อไปนี้:

************************** 1. แถว ******************** * ******
Slave_IO_State: กำลังรอให้มาสเตอร์ส่งกิจกรรม
มาสเตอร์_โฮสต์: 192.168.0.1
Master_User: Slave_user
มาสเตอร์_พอร์ต: 3306
เชื่อมต่อ_ลองอีกครั้ง: 60
Master_Log_File: mysql-bin.000002
Read_Master_Log_Pos: 107
Relay_Log_File: mysql-relay-bin.000003
Relay_Log_Pos: 253
Relay_Master_Log_File: mysql-bin.000002
Slave_IO_Running: ใช่
Slave_SQL_Running: ใช่
ทำซ้ำ_Do_DB:
ทำซ้ำ_Ignore_DB:
ทำซ้ำ_Do_Table:
Replicate_Ignore_Table:
ทำซ้ำ_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
ข้าม_เคาน์เตอร์: 0
Exec_Master_Log_Pos: 107
รีเลย์_ล็อก_สเปซ: 555
จนกระทั่ง_เงื่อนไข: ไม่มี
จนกระทั่ง_Log_ไฟล์:
จนถึง_Log_Pos: 0
Master_SSL_Allowed: ไม่
Master_SSL_CA_ไฟล์:
มาสเตอร์_SSL_CA_เส้นทาง:
มาสเตอร์_SSL_ใบรับรอง:
มาสเตอร์_SSL_Cipher:
มาสเตอร์_SSL_คีย์:
Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: ไม่
Last_IO_ข้อผิดพลาด: 0
Last_IO_Error:
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Master_Server_Id: 1
1 แถวในชุด (0.00 วินาที)

เนื่องจากไม่มีข้อผิดพลาดเกิดขึ้น เราจึงสามารถสรุปได้ว่ามีการกำหนดค่าการจำลองอย่างถูกต้อง

เป็น เครื่องมือที่ดีการปรับขนาด แต่ข้อเสียเปรียบหลักคือการไม่ประสานข้อมูลของการคัดลอกข้อมูลและความล่าช้าซึ่งอาจเป็นเรื่องสำคัญ

การใช้โซลูชันที่ทันสมัยกว่าทำให้คุณสามารถหลีกเลี่ยงปัญหาเหล่านี้ได้อย่างสมบูรณ์ ติดตั้งง่าย เชื่อถือได้ และไม่จำเป็นต้องคัดลอกดัมพ์ฐานข้อมูลด้วยตนเอง

ต่อไปนี้เป็นคำอธิบายโดยย่อเกี่ยวกับวิธีตั้งค่าการจำลองแบบเต็มรูปแบบของเซิร์ฟเวอร์ MySQL ของคุณ สันนิษฐานว่าฐานข้อมูลทั้งหมดจะถูกจำลองแบบและไม่ได้กำหนดค่าการจำลองแบบก่อนหน้านี้ หากต้องการทำตามขั้นตอนที่นี่ให้เสร็จสิ้น คุณจะต้องหยุดการทำงานของเซิร์ฟเวอร์หลักในช่วงเวลาสั้นๆ

นี่เป็นวิธีที่ง่ายที่สุดในการติดตั้งเซิร์ฟเวอร์ทาส แต่ไม่ใช่วิธีเดียวเท่านั้น ตัวอย่างเช่น หากมีอิมเมจของเซิร์ฟเวอร์หลักอยู่แล้ว เซิร์ฟเวอร์หลักมีการตั้งค่า ID เซิร์ฟเวอร์และการบันทึกอยู่แล้ว เซิร์ฟเวอร์ทาสสามารถติดตั้งได้โดยไม่ต้องหยุดเซิร์ฟเวอร์หลัก หรือแม้แต่ตั้งค่าล็อคการอัปเดต (สำหรับข้อมูลเพิ่มเติม ดูหัวข้อ 4.10 .7 คำถามที่พบบ่อยเกี่ยวกับการจำลองแบบบ่อยครั้ง

หากต้องการเป็นกูรูด้านการจำลอง MySQL อย่างแท้จริง เราขอแนะนำให้คุณเรียนรู้ ทำความเข้าใจ และลองใช้คำสั่งทั้งหมดที่กล่าวถึงใน ดูหัวข้อ 4.10.6 คำสั่ง SQL ที่เกี่ยวข้องกับการจำลองข้อมูล คุณควรตรวจสอบตัวเลือกสำหรับการเริ่มการจำลองแบบจากไฟล์ `my.cnf' ในส่วน 4.10.5 ตัวเลือกการจำลองแบบจากไฟล์ `my.cnf'

1. ตรวจสอบให้แน่ใจว่าได้ติดตั้ง MySQL เวอร์ชันล่าสุดบนเซิร์ฟเวอร์หลักและเซิร์ฟเวอร์รองแล้ว ใช้เวอร์ชัน 3.23.29 หรือสูงกว่า รุ่นก่อนหน้านี้ใช้รูปแบบบันทึกไบนารีที่แตกต่างกันและมีข้อบกพร่องที่ได้รับการแก้ไขในรุ่นที่ใหม่กว่า คำขอสำคัญ: โปรดอย่าส่งรายงานข้อผิดพลาดโดยไม่ตรวจสอบว่ามีข้อบกพร่องในรุ่นล่าสุดหรือไม่
2. ตั้งค่าผู้ใช้การจำลองแบบแยกต่างหากบนเซิร์ฟเวอร์หลักด้วยสิทธิ์ FILE (ใน MySQL เวอร์ชันก่อนหน้า 4.0.2) หรือ REPLICATION SLAVE ใน MySQL เวอร์ชันใหม่กว่า ผู้ใช้รายนี้ต้องมีสิทธิ์ในการเชื่อมต่อจากเซิร์ฟเวอร์ทาสทั้งหมดด้วย หากผู้ใช้จะทำการจำลองแบบเท่านั้น (แนะนำ) ก็ไม่จำเป็นต้องได้รับสิทธิ์เพิ่มเติมใดๆ ตัวอย่างเช่น ในการสร้างผู้ใช้ชื่อ repl ที่สามารถเข้าถึงเซิร์ฟเวอร์หลักจากโฮสต์ใดๆ คุณสามารถใช้คำสั่งต่อไปนี้: mysql> GRANT FILE ON *.* TO repl@"%" IDENTIFIED BY " ";
3. ปิดระบบ MySQL บนเซิร์ฟเวอร์หลัก mysqladmin -u root -p ปิดระบบ
4. สร้างรูปภาพของข้อมูลทั้งหมดบนเซิร์ฟเวอร์หลัก วิธีที่ง่ายที่สุดในการทำเช่นนี้ (บน Unix) คือการสร้าง ทาร์เก็บถาวรไดเร็กทอรีข้อมูลทั้งหมดของคุณ ตำแหน่งที่แน่นอนของไดเร็กทอรีข้อมูลขึ้นอยู่กับการติดตั้งของคุณ tar -cvf /tmp/mysql-snapshot.tar /path/to/data-dir ผู้ใช้ Windows สามารถใช้ WinZIP หรือโปรแกรมอื่นที่คล้ายกันเพื่อสร้างไฟล์เก็บถาวรไดเร็กทอรีข้อมูล
5. ใน my.cnf บนเซิร์ฟเวอร์หลัก ให้เพิ่มรายการลงในส่วนรายการ log-bin และ server-id=unique number ให้กับส่วนแล้วรีสตาร์ทเซิร์ฟเวอร์ เป็นสิ่งสำคัญมากที่ ID ของเซิร์ฟเวอร์ทาสจะแตกต่างจาก ID ของเซิร์ฟเวอร์หลัก เราสามารถพิจารณาว่า ID เซิร์ฟเวอร์มีบทบาทเป็นที่อยู่ IP โดยจะระบุเซิร์ฟเวอร์โดยไม่ซ้ำกันในหมู่ผู้เข้าร่วมการจำลอง เซิร์ฟเวอร์ถังเข้าสู่ระบบ-id = 1
6. รีสตาร์ท MySQL บนเซิร์ฟเวอร์หลัก
7. เพิ่มสิ่งต่อไปนี้ใน my.cnf บนเซิร์ฟเวอร์ทาส: master-host= master-user= master-password= master-port= server-id= แทนที่ค่าด้วยค่าที่เหมาะสมสำหรับระบบของคุณ . ค่ารหัสเซิร์ฟเวอร์จะต้องแตกต่างกันในแต่ละเซิร์ฟเวอร์ที่มีส่วนร่วมในการจำลองแบบ หากไม่ได้กำหนดค่ารหัสเซิร์ฟเวอร์ ค่าดังกล่าวจะถูกตั้งค่าเป็น 1 หากไม่ได้กำหนดค่ารหัสโฮสต์หลักด้วย ค่าดังกล่าวจะถูกตั้งค่าเป็น 2 โปรดทราบว่าหากไม่ระบุค่ารหัสเซิร์ฟเวอร์ เซิร์ฟเวอร์หลักก็จะเป็นเซิร์ฟเวอร์หลัก จะปฏิเสธการเชื่อมต่อกับเซิร์ฟเวอร์ทาสทั้งหมด และเซิร์ฟเวอร์ทาสปฏิเสธที่จะเชื่อมต่อกับเซิร์ฟเวอร์หลัก ดังนั้น คุณสามารถละเว้นการตั้งค่ารหัสเซิร์ฟเวอร์ได้หากคุณสำรองข้อมูลโดยใช้บันทึกไบนารี
8. คัดลอกข้อมูลสแน็ปช็อตไปยังไดเร็กทอรีข้อมูลบนเซิร์ฟเวอร์ทาส ตรวจสอบให้แน่ใจว่าสิทธิ์ของไฟล์และไดเร็กทอรีถูกต้อง ผู้ใช้ที่ใช้ MySQL จะต้องสามารถอ่านและเขียนข้อมูลได้ในลักษณะเดียวกับบนเซิร์ฟเวอร์หลัก
9. รีสตาร์ทเซิร์ฟเวอร์ทาส

หลังจากทำตามขั้นตอนเหล่านี้แล้ว เซิร์ฟเวอร์ทาสจะต้องเชื่อมต่อกับเซิร์ฟเวอร์หลักและปรับข้อมูลให้เข้ากับการเปลี่ยนแปลงใด ๆ ที่เกิดขึ้นบนเซิร์ฟเวอร์หลักหลังจากยอมรับอิมเมจแล้ว

หากไม่ได้ตั้งค่าเซิร์ฟเวอร์ -id สำหรับเซิร์ฟเวอร์ทาส ข้อผิดพลาดต่อไปนี้จะถูกบันทึก:

คำเตือน: ควรตั้งค่า server_id เป็นค่าที่ไม่ใช่ 0 หากตั้งค่า master_host เซิร์ฟเวอร์จะไม่ทำหน้าที่เป็นทาส (คำเตือน: หากระบุ master_host ไว้ server_id ควรตั้งค่าเป็นค่าที่ไม่ใช่ศูนย์ เซิร์ฟเวอร์จะไม่ทำหน้าที่เป็นเซิร์ฟเวอร์ทาส)

หากไม่ได้ตั้งค่า ID เซิร์ฟเวอร์หลัก เซิร์ฟเวอร์ทาสจะไม่สามารถเชื่อมต่อกับเซิร์ฟเวอร์หลักได้

ถ้าเซิร์ฟเวอร์ทาสไม่สามารถจำลองแบบด้วยเหตุผลใดก็ตาม สามารถพบได้ในบันทึกข้อผิดพลาดบนเซิร์ฟเวอร์ทาส

หลังจากที่เซิร์ฟเวอร์ทาสเริ่มการจำลอง ไฟล์ `master.info' จะปรากฏในไดเร็กทอรีเดียวกันกับบันทึกข้อผิดพลาด เซิร์ฟเวอร์ทาสใช้ไฟล์ `master.info' เพื่อติดตามรายการบันทึกไบนารีจากเซิร์ฟเวอร์หลัก ประมวลผล อย่าลบหรือแก้ไขไฟล์นี้เว้นแต่คุณจะแน่ใจว่าจำเป็น แม้ว่าคุณจะมีความมั่นใจเช่นนั้น แต่ก็ยังดีกว่าถ้าใช้คำสั่ง CHANGE MASTER TO

ไม่นานมานี้ผมถูกขอให้พูดถึง การจำลองแบบใน MySQL- ฉันตัดสินใจว่าหัวข้อนี้อาจเป็นประโยชน์กับหลาย ๆ คนดังนั้นในบทความนี้ฉันจะพูดถึง การจำลองแบบใน MySQL คืออะไร จำเป็นเมื่อใด และจะกำหนดค่าอย่างไร.

ภารกิจหลักของการจำลองแบบคือ รวมพลังของเซิร์ฟเวอร์หลายตัว- สมมติว่าเว็บไซต์ของคุณมีเซิร์ฟเวอร์เฉพาะ แต่เมื่อเวลาผ่านไป มีผู้เยี่ยมชมมากและไม่สามารถทนต่อภาระงานได้อีกต่อไป ส่งผลให้เซิร์ฟเวอร์เริ่มช้าลงและหยุดทำงานเป็นประจำ วิธีที่ง่ายที่สุดคือซื้อเซิร์ฟเวอร์ที่ทรงพลังกว่านี้ และนี่คือสิ่งที่คนส่วนใหญ่ทำ แต่ไม่ช้าก็เร็วก็ถึงเวลาที่ต้นทุนในการเพิ่มราคาของเซิร์ฟเวอร์ไม่สอดคล้องกับประสิทธิภาพที่เพิ่มขึ้นดังนั้นจึงมีกำไรมากกว่าที่จะซื้อ 2 เซิร์ฟเวอร์ที่แตกต่างกันด้วยเงินที่น้อยลง

เป็นผลให้ฐานข้อมูลของคุณอยู่บนเซิร์ฟเวอร์สองเครื่องพร้อมกัน เมื่อเซิร์ฟเวอร์หลักตัวหนึ่ง (หรือที่เรียกว่าเซิร์ฟเวอร์หลัก) ไม่สามารถรับมือได้อีกต่อไป ก็จะเปลี่ยนไปใช้เซิร์ฟเวอร์สำรอง

ทั้งหมด คำขออัพเดตฐานข้อมูลจะไปที่เซิร์ฟเวอร์หลักเสมอ- หลังจากอัปเดตเฮดเซิร์ฟเวอร์แล้ว ระบบจะใส่ข้อมูลเกี่ยวกับสิ่งนี้ไว้ แยกไฟล์โดยที่เซิร์ฟเวอร์ทาสรับข้อมูลทั้งหมด แต่การดำเนินการสุ่มตัวอย่างซึ่งโดยปกติจะเป็นส่วนใหญ่และช้าที่สุด สามารถถ่ายโอนไปยังเซิร์ฟเวอร์ทาสได้แล้ว เนื่องจากข้อมูลทั้งสองจะเหมือนกัน

ทีนี้มาคิดออกกัน วิธีกำหนดค่าการจำลองแบบใน MySQL:

1. ติดตั้งให้มากที่สุด MySQL เวอร์ชันล่าสุดไปยังเซิร์ฟเวอร์ทั้งหมด
2. สร้างผู้ใช้ที่มีสิทธิ์บนเซิร์ฟเวอร์หลัก แทนที่ทาส- สำหรับที่อยู่ที่สามารถเชื่อมต่อได้ ให้ระบุ " ทั้งหมด".
3. หยุดเซิร์ฟเวอร์ทั้งหมด
4. ในการตั้งค่า MySQL(ในไฟล์ my.cnf) ในบทที่ เพิ่มบรรทัดต่อไปนี้: log-bin
   server-id=1 โปรดทราบว่า รหัสเซิร์ฟเวอร์จะต้องแตกต่างกันบนเซิร์ฟเวอร์ทั้งหมด อันที่จริงนี่คือสิ่งที่ทำให้เซิร์ฟเวอร์หนึ่งแตกต่างจากเซิร์ฟเวอร์อื่น
5. บนเซิร์ฟเวอร์ทาส ให้เพิ่มการตั้งค่า MySQLบรรทัดต่อไปนี้: master-host=master_host_name
   master-user=login ของ create_user
   master-password=รหัสผ่านของ create_user
   master-port=port_for_connecting_to_the_master_server
   เซิร์ฟเวอร์-id=id_of_this_slave_server
6. ย้ายฐานทั้งหมดจากเซิร์ฟเวอร์หลักไปจนถึงทาส
7. วิ่งหัวหน้าเซิร์ฟเวอร์ แล้วก็ทาสทั้งหมด

หากต้องการใช้การจำลองแบบใน MySQL ได้สำเร็จ คุณต้อง:

• ตรวจสอบให้แน่ใจว่าเวอร์ชัน MySQL >= เวอร์ชันที่ติดตั้งบน Master ได้รับการติดตั้งบนเซิร์ฟเวอร์ที่ทำหน้าที่เป็น Slave การจำลองแบบยังสามารถทำได้ในลำดับย้อนกลับ โดยที่ Master มีมากกว่านั้น เวอร์ชั่นใหม่บน Slave ด้วยอันที่เก่ากว่า แต่ไม่รับประกันการทำงานของตัวเลือกนี้
• ตรวจสอบการเชื่อมต่อจากเซิร์ฟเวอร์ MySQL Slave ไปยัง Master (# mysql -hMASTERHOST -uroot -p) เนื่องจากอาจถูกปิดในไฟร์วอลล์

การจำลองแบบ Master-Slave ของฐานข้อมูล MySQL หนึ่งฐานข้อมูล

นี่เป็นตัวอย่างง่ายๆ การจำลองแบบแบบ master-slave ของหนึ่ง ฐานข้อมูล MySQL - ผู้ที่ทำสิ่งนี้เป็นครั้งแรกควรเริ่มต้นด้วยตัวอย่างนี้และปฏิบัติตามคำแนะนำอย่างเคร่งครัด

ขั้นแรก คุณต้องลงทะเบียน ID ที่แตกต่างกันสำหรับเซิร์ฟเวอร์ Master และ Slave บนเซิร์ฟเวอร์หลักคุณต้องเปิดใช้งานบันทึกไบนารี (log-bin) ระบุฐานข้อมูลสำหรับการจำลองแบบและสร้างผู้ใช้เซิร์ฟเวอร์ทาสซึ่งเซิร์ฟเวอร์ทาสจะได้รับข้อมูลจากต้นแบบ บน เซิร์ฟเวอร์ทาสบันทึกการถ่ายทอดเปิดอยู่ มีการระบุฐานข้อมูลสำหรับการจำลองแบบ และการจำลองแบบทาสเริ่มต้นขึ้น

MASTER: การดำเนินการที่ทำบนเซิร์ฟเวอร์ MySQL Master

แก้ไข my.cnf - ไฟล์กำหนดค่า MySQL ตำแหน่งของมันขึ้นอยู่กับ ระบบปฏิบัติการและการตั้งค่าของ MySQL เอง ใน my.cnf พารามิเตอร์ต่อไปนี้จะถูกเพิ่มในส่วนต่างๆ:

เซิร์ฟเวอร์-id= 1

# เส้นทางสู่บันทึกไบนารี
# ชื่อไฟล์ถูกเขียนโดยไม่มีนามสกุล เนื่องจากนามสกุลจะถูกติดตั้งต่อไป
# โดยเซิร์ฟเวอร์ MySQL อัตโนมัติ (.000001, .000002 ฯลฯ)
# ขอแนะนำให้ค้นหา mysql-bin ในรูทของไดเร็กทอรีที่เก็บฐานข้อมูลทั้งหมด
# เพื่อหลีกเลี่ยงปัญหาการอนุญาต
log-bin =/ var/ lib/ mysql/ mysql- bin

# ชื่อของฐานข้อมูล MySQL ที่จะถูกจำลองแบบ

หลังจากแก้ไข my.cnf แล้ว คุณควรรีสตาร์ท MySQL ไฟล์อย่างน้อยหนึ่งไฟล์ mysql-bin.000001, mysql-bin.000002, ... ควรปรากฏในไดเร็กทอรีสำหรับจัดเก็บบันทึกไบนารี (log-bin)

ตอนนี้คุณต้องเชื่อมต่อกับ MySQL ในฐานะผู้ใช้ที่มีสิทธิ์สูงสุดและสร้างผู้ใช้ (rpluser_s500) ด้วยรหัสผ่าน (แทนที่ PASSW) ซึ่งเซิร์ฟเวอร์ Slave จะได้รับข้อมูลเกี่ยวกับการอัพเดตฐานข้อมูล:

mysql> ให้ทาสการจำลองแบบ GRANT ON * .* TO "rpluser _ s500"@"% " ระบุโดย "PASSW" ;
mysql> สิทธิ์ล้าง ;

$ mysqldump -- ต้นแบบ- ข้อมูล - hHOST - uUSER - p dbreplica > dbreplica.sql

ดัมพ์สามารถนำมาจากฐานข้อมูลภายใต้โหลดได้ แต่ควรสังเกตว่าหากฐานข้อมูลมีขนาดใหญ่ ในขณะที่กำลังเขียนดัมพ์ ฐานข้อมูลจะไม่สามารถเขียนได้

SALVE: การดำเนินการที่ทำบนเซิร์ฟเวอร์ MySQL Slave

ก่อนอื่น คุณต้องแก้ไข my.cnf ในส่วน:

# รหัสเซิร์ฟเวอร์หลัก (ตัวเลขตั้งแต่ 1 ถึง 4294967295)
เซิร์ฟเวอร์-id= 500

# เส้นทางไปยังบันทึกการถ่ายทอดซึ่งเก็บข้อมูลที่ได้รับจากเซิร์ฟเวอร์หลัก
# ข้อกำหนดเหมือนกับบันทึกไบนารี
รีเลย์- บันทึก =/ var/ lib/ mysql/ mysql- รีเลย์- bin
รีเลย์- บันทึก- ดัชนี =/ var/ lib/ mysql/ mysql- รีเลย์- bin .index

# ชื่อของฐานข้อมูลที่จะเขียนการเปลี่ยนแปลงทั้งหมด
# เกิดขึ้นในฐานข้อมูลที่มีชื่อเดียวกันบนเซิร์ฟเวอร์หลัก
ทำซ้ำ- do- db= "dbreplica"

หลังจากแก้ไข my.cnf แล้ว ให้รีสตาร์ท MySQL

mysql> สร้างฐานข้อมูล dbreplica

ตอนนี้คุณต้องอัปโหลดดัมพ์เข้าไป:

$ mysql - uROOT - p dbreplica< dbreplica.sql

ต่อไป เราตั้งค่าการเชื่อมต่อกับเซิร์ฟเวอร์หลัก โดยที่ MASTER_HOSTNAME_OR_IP จะถูกแทนที่ด้วยที่อยู่หรือ ip ของเซิร์ฟเวอร์หลัก MySQL และ MASTER_USER และ PASSWORD เป็นข้อมูลประจำตัวของผู้ใช้ที่สร้างขึ้นบนเซิร์ฟเวอร์ Master เพื่อเชื่อมต่อกับ Slave:

mysql> เปลี่ยน MASTER เป็น MASTER_HOST = "MASTER _HOSTNAME_OR_IP", MASTER_USER = "rpluser _ s500", รหัสผ่าน = "รหัสผ่าน" ;

หลังจากรันคำขอนี้ ไฟล์ master.info จะถูกสร้างขึ้นในไดเร็กทอรีที่จัดเก็บฐานข้อมูล ซึ่งมีการเขียนข้อมูลเกี่ยวกับการเชื่อมต่อกับ Master

ตอนนี้ เพื่อเริ่มการจำลองแบบ สิ่งที่เหลืออยู่คือส่งคำขอไปยัง MySQL:

mysql> เริ่มทาส;

หลังจากนี้ หากทุกอย่างเป็นไปด้วยดี คุณจะสามารถดูได้ว่าการเปลี่ยนแปลงทั้งหมดในฐานข้อมูลบนเซิร์ฟเวอร์ Master ปรากฏในฐานข้อมูลบน Slave อย่างไร

การตั้งค่าการจำลองแบบ MySQL

การตั้งค่าไฟล์บันทึกไบนารี (log-bin)

บันทึกไบนารี MySQLใช้เพื่อบันทึกการเปลี่ยนแปลงที่เกิดขึ้นในฐานข้อมูลเซิร์ฟเวอร์ สำหรับการจำลองข้อมูล จะต้องเปิดใช้งานบนเซิร์ฟเวอร์ Master; บนเซิร์ฟเวอร์ Slave ควรใช้เฉพาะในกรณีที่ Slave เป็น Master สำหรับ MySQL Slave อื่นด้วย Log bin ถูกเปิดใช้งานโดยการเพิ่มพารามิเตอร์ในส่วน mysql.cnf:

log-bin = mysql-bin

ในการตั้งค่าตัวอย่าง: “การจำลองแบบ Master-slave ของฐานข้อมูล MySQL หนึ่งฐานข้อมูล” มีการเปิดใช้งานการบันทึกไบนารีสำหรับฐานข้อมูล MySQL ทั้งหมด หากคุณต้องการบันทึกเฉพาะบางฐานข้อมูล เช่น DB_NAME1 และ DB_NAME2 คุณต้องเพิ่มตัวเลือกให้กับ my.cnf ของวิซาร์ด binlog-do-db:

binlog-do-db= "DB _NAME1"
binlog-do-db= "DB _NAME2"

นั่นคือคุณต้องแสดงรายการชื่อฐานข้อมูลทั้งหมด โดยที่แต่ละฐานข้อมูลมีบรรทัดของตัวเองพร้อมกับพารามิเตอร์ binlog-do-db คำตรงข้ามของโอเปอเรเตอร์นี้คือ binlog-ละเว้น-db="DB_NAME" ซึ่งบอกให้ MySQL บันทึกฐานข้อมูลทั้งหมด ยกเว้นที่ระบุไว้ในพารามิเตอร์ binlog-ignore-db

หากคุณระบุฐานข้อมูลโดยคั่นด้วยเครื่องหมายจุลภาค เช่น:

การใช้พารามิเตอร์ binlog-ignore-db ไม่ถูกต้อง!

binlog- ละเว้น- db = "DB _ NAME3, DB_ NAME4"

เมื่อมองแวบแรกทุกอย่างจะทำงานตามที่ควรจะเป็น - ไม่มีข้อผิดพลาด แต่ในความเป็นจริงแล้ว ฐานข้อมูล DB_NAME3 และ DB_NAME4 จะไม่ถูกแยกออกจากบันทึกไบนารี: MySQL จะพิจารณาว่า "DB_NAME3, DB_NAME4" เป็นฐานข้อมูลเดียวที่มีชื่อ " DB_NAME3, DB_NAME4 " (เช่น มีเครื่องหมายจุลภาคและช่องว่างในชื่อฐานข้อมูล)!

ก่อนที่จะรวมหรือแยกฐานข้อมูลออกจากบันทึกไบนารี่ คุณต้องเข้าใจว่าบันทึกไบนารี่ของ MySQL ทำงานอย่างไรและในโหมดใด ซึ่งจะกำหนดว่าการจำลองแบบจะทำงานได้อย่างน่าเชื่อถือ ความสอดคล้องของข้อมูล และจำนวนข้อผิดพลาดที่เกิดขึ้นระหว่างการใช้งาน (ขึ้นอยู่กับการกำจัดทั้งหมด)

พารามิเตอร์ที่รับผิดชอบรูปแบบการจัดเก็บข้อมูลของบันทึกไบนารี - binlog_formatซึ่งเริ่มต้นจาก MySQL 5.1 สามารถรับได้ 3 ค่า: STATEMENT (ใช้เป็นค่าเริ่มต้นใน MySQL = 5.7.7) และ MIXED

คำชี้แจง - โหมดบันทึกไบนารีของ MySQL

คำแถลง- ในโหมดนี้ คำสั่ง SQL ทั่วไปสำหรับการเพิ่ม อัปเดต และลบข้อมูลพร้อมข้อมูลบริการเพิ่มเติมจะถูกเขียนลงในบันทึกไบนารี โดยการเปิดล็อกอินดังกล่าว โปรแกรมแก้ไขข้อความคุณจะพบคำร้องขอเปลี่ยนแปลงข้อมูลในฐานข้อมูล รูปแบบข้อความ- ข้อดีของการใช้ binlog_format=STATEMENT: ขนาดไฟล์ค่อนข้างเล็ก ความสามารถในการดูบันทึกใน mysqlbinlog หรือ PHPMyAdmin ข้อเสียอยู่ที่การใช้คำสั่ง SQL ซึ่งมีรายละเอียดเพิ่มเติมด้านล่างนี้

สมมติว่าข้อมูลถูกเพิ่มลงในบันทึกไบนารีสำหรับฐานข้อมูลเดียวเท่านั้นที่เรียกว่า users (binlog - do- db= "ผู้ใช้"- แบบสอบถามต่อไปนี้ซึ่งส่งผลโดยตรงต่อฐานข้อมูล "ผู้ใช้" จะไม่ถูกบันทึกในบันทึกไบนารี:

ตัวอย่างหมายเลข 1

ใช้ไคลเอนต์;
อัปเดต users.accounts จำนวน SET = จำนวน + 5 ;

ลักษณะการทำงานนี้มีสาเหตุมาจากความจริงที่ว่ามีการใช้ฐานข้อมูล "ไคลเอนต์" เริ่มต้นซึ่งไม่ได้บันทึกไว้ในบันทึกไบนารีในโหมดคำสั่ง

อีกตัวอย่างหนึ่งคือเมื่อคำขอไปยังฐานข้อมูลที่ไม่อยู่ใน binlog-do-db จบลงในบันทึกไบนารี:

ตัวอย่างหมายเลข 2

ใช้ผู้ใช้;
อัปเดต client.discounts SET เปอร์เซ็นต์ = เปอร์เซ็นต์ + 5 ;

สิ่งนี้ยังคงเกิดขึ้นในลักษณะเดียวกันเนื่องจากการใช้ฐานข้อมูลเริ่มต้น แต่ในกรณีนี้ ข้อความค้นหา "ผิด" หรือ "พิเศษ" จะถูกเขียนลงในบันทึกไบนารี

ทั้งคำขอแรกและครั้งที่สองสามารถนำไปสู่ผลลัพธ์ที่ไม่คาดคิดเมื่อใช้การจำลองแบบบนเซิร์ฟเวอร์ Slave ในกรณีของคำขอจากตัวอย่างแรก ข้อมูลบนเซิร์ฟเวอร์ Master และ Slave จะแตกต่างกัน: amount=amount+5 จะดำเนินการบน Master แต่ไม่ใช่บน Slave เมื่อใช้คำขอที่สอง คำขอจะถูกส่งไปยัง Slave เพื่อเปลี่ยนข้อมูลในฐานข้อมูลที่ไม่ได้ลงทะเบียนในรายการทาส และการจำลองแบบ Master-Slave จะล้มเหลวหากไม่มีฐานข้อมูลไคลเอนต์บนทาสหรือ . จะทำการเปลี่ยนแปลงตารางฐานข้อมูลหากมี ดังนั้น ในระหว่างการจำลองแบบ Master-Slave ในโหมดคำสั่งบันทึกไบนารี คุณสามารถทำการเปลี่ยนแปลงฐานข้อมูลของเซิร์ฟเวอร์ทาส ซึ่งไม่ได้มีไว้สำหรับการจำลองแบบ!เราเดาได้แค่ว่าการเปลี่ยนแปลงดังกล่าวจะส่งผลอย่างไร ดังนั้นคุณต้องระมัดระวังอย่างมากเมื่อใช้โหมดบันทึกไบนารีของ Statement

ปัญหาอื่นเมื่อใช้บันทึกไบนารีในโหมดคำสั่งอาจปรากฏขึ้นหากเซิร์ฟเวอร์ Slave ได้รับการกำหนดค่าให้เขียนไปยังฐานข้อมูลที่มีชื่อแตกต่างจากต้นฉบับ ตัวอย่างเช่น ฐานข้อมูลหนึ่งถูกจำลองแบบจาก db_countries หลักไปยังทาส โดยที่ฐานข้อมูลเดียวกันเรียกว่า db_countries_slave (ชื่อฐานข้อมูลใหม่บนเซิร์ฟเวอร์ Slave ถูกกำหนดโดยพารามิเตอร์ ชื่อฐานข้อมูลใหม่ถูกกำหนดไว้แล้วสำหรับการจำลองแบบ: replication-do-db="db_countries_slave") ขณะที่ต้นแบบกำลังอัปเดตข้อมูลในฐานข้อมูลโดยใช้ USE db_countries และ UPDATE ชื่อ SET ... ทุกอย่างเรียบร้อยดี แต่ทันทีที่มีการร้องขอซึ่งระบุชื่อฐานข้อมูล เช่น UPDATE db_countries.names SET ... replication บน Slave หยุดโดยมีข้อผิดพลาด: ไม่มีตาราง "db_countries.names" ในแบบสอบถาม ฐานข้อมูลเริ่มต้น: "db_countries_slave" แบบสอบถาม: UPDATE db_countries.names SET ...- ไม่มีปัญหาดังกล่าวในโหมด ROW

ROW - โหมดบันทึกไบนารี

แถว- เมื่อเลือกวิธีการจัดเก็บบันทึกไบนารีนี้ เฉพาะการเปลี่ยนแปลงสำหรับฐานข้อมูลที่เลือกเท่านั้นที่จะถูกเขียนลงในไฟล์ในรูปแบบไบนารี ข้อมูลอาจใช้พื้นที่มากกว่าในโหมดใบแจ้งยอดมาก แต่การจำลองประเภทนี้มีข้อได้เปรียบหลักประการหนึ่ง - ในโหมดนี้ การจำลองแบบจะปลอดภัยกว่าการใช้คำสั่งมาก

เฉพาะข้อมูลที่เปลี่ยนแปลงสำหรับฐานข้อมูลที่กำหนดโดยใช้พารามิเตอร์ binlog-do-db หรือ binlog-ignore-db เท่านั้นที่ถูกเขียนลงในบันทึกไบนารี ฐานข้อมูลเริ่มต้นไม่ส่งผลกระทบต่อลักษณะการทำงานนี้ ด้วยเหตุนี้ หลังจากการสืบค้นจากตัวอย่างที่ 1 ข้อมูลอัปเดตจะจบลงในบันทึกไบนารี แต่ sql จากตัวอย่างที่สองจะไม่ถูกเขียนอีกต่อไป

มากกว่า คำอธิบายโดยละเอียดข้อดีและข้อเสียของโหมดคำสั่งและโหมดแถวสามารถรวบรวมได้จากเอกสารอย่างเป็นทางการเป็นภาษาอังกฤษ: 17.1.2.1 ข้อดีและข้อเสียของการจำลองแบบตามคำสั่งและตามแถว

MIXED - โหมดบันทึกไบนารี

ผสม- โหมดที่บันทึกไบนารี่ใช้โหมดการจำลอง 2 โหมดพร้อมกัน: คำสั่งและแถวเพื่อจัดเก็บข้อมูลเกี่ยวกับคำขอต่างๆ คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับวิธีการทำงานของโหมดบันทึกไบนารีแบบผสมได้จากเอกสารอย่างเป็นทางการเป็นภาษาอังกฤษ: 5.4.4.3 รูปแบบการบันทึกไบนารีแบบผสม นี่ไม่ได้เป็นการบอกว่านี่เป็นตัวเลือกในอุดมคติ แต่ถ้าคุณเข้าใจวิธีการทำงานของแบบผสม ก็สามารถนำมาใช้ในทางปฏิบัติได้

การล้างบันทึกไบนารีอัตโนมัติ - expir_logs_days

ตามค่าเริ่มต้น บันทึกไบนารีจะไม่ถูกล้างโดยอัตโนมัติ หากต้องการล้างถังบันทึกอัตโนมัติ ให้ใช้พารามิเตอร์expir_logs_days ซึ่งระบุจำนวนวันที่ MySQL จะจัดเก็บบันทึกไบนารี

ตัวอย่างการลบบันทึกไบนารีอัตโนมัติ ผ่านไปนานกว่า 10 วันนับตั้งแต่วันที่สร้าง

expir_logs_days= 10

การตั้งค่าบันทึกไบนารีที่มีประโยชน์อื่น ๆ

ผู้ใช้เพื่อเชื่อมต่อ Slave กับ Master

ด้วยการจำลองแบบ Master-Slave จำเป็นต้องมีบัญชีผู้ใช้อย่างน้อยหนึ่งบัญชีบนเซิร์ฟเวอร์ Master ซึ่ง Slave จะใช้ในการเชื่อมต่อ ข้อกำหนดสำหรับสิทธิ์การเข้าถึงของบัญชีดังกล่าว: สิทธิพิเศษ REPLICATION SLAVE เพียงอย่างเดียวคือการเปิดการเข้าถึงฐานข้อมูล ตาราง หรือเพิ่มสิทธิ์อื่นใดที่ไม่จำเป็น ผู้ใช้หนึ่งรายที่มี REPLICATION SLAVE สามารถใช้งานโดยเซิร์ฟเวอร์ทาสที่แตกต่างกันเพื่อรับข้อมูลจากเซิร์ฟเวอร์หลักพร้อมกัน หรือสามารถสร้างผู้ใช้แยกต่างหากสำหรับทาสแต่ละตัวได้

ไม่ควรใช้เพื่อการทำซ้ำ บัญชีกอปรด้วยสิทธิ์การเข้าถึงเพิ่มเติม การเข้าสู่ระบบและรหัสผ่านสำหรับการเชื่อมต่อกับเซิร์ฟเวอร์หลักจะถูกจัดเก็บไว้ในข้อความที่ชัดเจนบนทาส (ไฟล์ master.info ในไดเร็กทอรีที่มีฐานข้อมูล)

mysql> สร้างผู้ใช้ "replicat" @"10.0.0.1" ระบุโดย "pass" ;
mysql> GRANT REPLICATION SLAVE บน * .* TO "replicat" @"10.0.0.1" ;

ที่อยู่ IP 10.0.0.1 คือ IP ของเซิร์ฟเวอร์ Slave ซึ่งจะต้องถูกแทนที่ด้วยที่อยู่จริง ในการสืบค้น sql คุณสามารถแทนที่ที่อยู่ IP ด้วยสัญลักษณ์ % พิเศษ จากนั้นคุณสามารถเชื่อมต่อกับต้นแบบจากโฮสต์ใดก็ได้ แต่ด้วยเหตุผลด้านความปลอดภัย จะเป็นการดีกว่าถ้าคุณจำกัดตัวเองให้อยู่แค่ที่อยู่จริงของเซิร์ฟเวอร์ทาส

การตั้งค่าเพิ่มเติม

เพื่อให้การจำลองฐานข้อมูลที่ใช้ตารางและธุรกรรมประเภท InnoDB ถูกต้องที่สุด คุณต้องเพิ่มบรรทัดต่อไปนี้ในการกำหนดค่าเซิร์ฟเวอร์หลัก (ส่วน my.cnf):

innodb_flush_log_at_trx_commit= 1
sync_binlog=1

ฉันเริ่มคุ้นเคยกับการจำลองแบบของเซิร์ฟเวอร์ MySQL เมื่อไม่นานนี้ และในขณะที่ฉันทำการทดลองต่างๆ กับการกำหนดค่า ฉันก็จดบันทึกสิ่งที่ใช้ได้ผลสำหรับฉัน พอรวบรวมเนื้อหาได้ค่อนข้างมาก เลยเกิดไอเดียเขียนบทความนี้ขึ้นมา ฉันได้พยายามรวบรวมเคล็ดลับและวิธีแก้ปัญหาสำหรับปัญหาพื้นฐานที่สุดบางข้อที่ฉันพบ ฉันจะให้ลิงก์ไปยังเอกสารประกอบและแหล่งข้อมูลอื่นๆ ตลอดทาง ฉันไม่สามารถแกล้งทำเป็นอธิบายได้ทั้งหมด แต่ฉันหวังว่าบทความนี้จะมีประโยชน์

แนะนำสั้น ๆ

การจำลองแบบ (จากละติน replico - ฉันทำซ้ำ) คือการจำลองแบบของการเปลี่ยนแปลงข้อมูลจากเซิร์ฟเวอร์ฐานข้อมูลหลักไปยังเซิร์ฟเวอร์ที่ขึ้นต่อกันตั้งแต่หนึ่งเซิร์ฟเวอร์ขึ้นไป เราจะเรียกเซิร์ฟเวอร์หลัก ผู้เชี่ยวชาญและขึ้นอยู่กับ - แบบจำลอง.
การเปลี่ยนแปลงข้อมูลที่เกิดขึ้นบนต้นแบบจะถูกทำซ้ำบนเรพลิกา (แต่ไม่ใช่ในทางกลับกัน) ดังนั้น การสืบค้นเพื่อเปลี่ยนแปลงข้อมูล (INSERT, UPDATE, DELETE ฯลฯ) จะถูกดำเนินการบนต้นแบบเท่านั้น ในขณะที่การสืบค้นเพื่ออ่านข้อมูล (หรืออีกนัยหนึ่งคือ SELECT) สามารถดำเนินการได้ทั้งบนแบบจำลองและต้นแบบ กระบวนการเรพลิเคชันบนเรพลิกาตัวใดตัวหนึ่งไม่ส่งผลกระทบต่อการทำงานของเรพลิกาอื่น และในทางปฏิบัติแล้วจะไม่ส่งผลกระทบต่อการทำงานของต้นแบบ
การจำลองแบบจะดำเนินการโดยใช้บันทึกไบนารีที่เก็บรักษาไว้บนต้นแบบ โดยจะจัดเก็บการสืบค้นทั้งหมดที่นำไปสู่ ​​(หรืออาจนำไปสู่) การเปลี่ยนแปลงในฐานข้อมูล (การสืบค้นจะไม่ถูกบันทึกอย่างชัดเจน ดังนั้น หากคุณต้องการดู คุณจะต้องใช้ยูทิลิตี mysqlbinlog) binlogs จะถูกถ่ายโอนไปยังแบบจำลอง (binlog ที่ดาวน์โหลดจากต้นแบบเรียกว่า "relay binlog") และการสืบค้นที่เก็บไว้จะถูกดำเนินการโดยเริ่มจากตำแหน่งที่แน่นอน สิ่งสำคัญคือต้องเข้าใจว่าในระหว่างการจำลองแบบ ไม่ใช่ข้อมูลที่เปลี่ยนแปลงเท่านั้นที่ถูกถ่ายโอน แต่เป็นเพียงแบบสอบถามที่ทำให้เกิดการเปลี่ยนแปลงเท่านั้น
ด้วยการจำลองแบบ เนื้อหาของฐานข้อมูลจะถูกทำซ้ำบนเซิร์ฟเวอร์หลายเครื่อง เหตุใดจึงต้องหันไปพึ่งการทำซ้ำ? มีสาเหตุหลายประการ:

• ประสิทธิภาพและความสามารถในการขยายขนาด- เซิร์ฟเวอร์เครื่องหนึ่งอาจไม่สามารถจัดการโหลดที่เกิดจากการดำเนินการอ่านและเขียนพร้อมกันในฐานข้อมูลได้ ประโยชน์ของการสร้างเรพลิกาจะยิ่งมีมากขึ้นตามการอ่านต่อการเขียนที่คุณมีในระบบของคุณมากขึ้น
• ความอดทนต่อความผิดพลาด- ในกรณีที่แบบจำลองล้มเหลว คำขออ่านทั้งหมดสามารถถ่ายโอนไปยังต้นแบบได้อย่างปลอดภัย หากต้นแบบล้มเหลว คำขอเขียนสามารถโอนไปยังเรพลิกาได้ (หลังจากที่ต้นแบบได้รับการกู้คืนแล้ว ก็สามารถเข้ามารับหน้าที่แทนเรพลิกาได้)
• การสำรองข้อมูล- แบบจำลองสามารถ "ช้าลง" ได้ชั่วขณะหนึ่งเพื่อดำเนินการ mysqldump แต่ต้นแบบไม่สามารถทำได้
• การคำนวณเลื่อนออกไป- การสืบค้น SQL ที่หนักหน่วงและช้าสามารถดำเนินการบนแบบจำลองที่แยกจากกันโดยไม่ต้องกลัวว่าจะถูกรบกวน ดำเนินการตามปกติระบบทั้งหมด

นอกจากนี้ยังมีฟีเจอร์อื่นๆ ที่น่าสนใจอีกด้วย เนื่องจากไม่ใช่ข้อมูลที่ถูกถ่ายโอนไปยังเรพลิกา แต่เป็นคิวรีที่ทำให้เกิดการเปลี่ยนแปลง เราจึงสามารถใช้โครงสร้างตารางที่แตกต่างกันบนต้นแบบและเรพลิกาได้ โดยเฉพาะประเภทของตาราง (เครื่องยนต์) หรือชุดดัชนีอาจแตกต่างกัน เช่น นำไปปฏิบัติ ค้นหาข้อความแบบเต็มเราสามารถใช้ประเภทตาราง MyISAM บนแบบจำลองได้ แม้ว่าต้นแบบจะใช้ InnoDB ก็ตาม

กำลังตั้งค่าการจำลอง

สมมติว่าเรามีฐานข้อมูล MySQL ที่ใช้งานได้ ซึ่งเต็มไปด้วยข้อมูลและเปิดใช้งานแล้ว และด้วยเหตุผลประการหนึ่งที่อธิบายไว้ข้างต้น เราจะเปิดใช้งานการจำลองแบบเซิร์ฟเวอร์ของเรา ข้อมูลเริ่มต้นของเรา:

• ที่อยู่ IP หลักคือ 192.168.1.101 ส่วนแบบจำลองคือ 192.168.1.102
• ติดตั้งและกำหนดค่า MySQL แล้ว
• คุณต้องกำหนดค่าการจำลองฐานข้อมูล testdb
• เราสามารถหยุดวิซาร์ดไว้ชั่วคราวได้
• แน่นอนว่าเรารูทเครื่องทั้งสองเครื่องแล้ว

การตั้งค่าตัวช่วยสร้าง

อย่าลืมระบุ ID เซิร์ฟเวอร์ที่ไม่ซ้ำกัน เส้นทางสำหรับบันทึกไบนารี และชื่อของฐานข้อมูลสำหรับการจำลองในส่วน:
เซิร์ฟเวอร์-id = 1
log-bin = /var/lib/mysql/mysql-bin
ทำซ้ำ-do-db = testdb
ตรวจสอบให้แน่ใจว่าคุณมีพื้นที่ดิสก์เพียงพอสำหรับบันทึกไบนารี

มาเพิ่มผู้ใช้การจำลองแบบซึ่งจะดำเนินการจำลองแบบสิทธิ์ สิทธิ์ "การจำลองแบบทาส" จะเพียงพอแล้ว:
mysql@master> ให้สิทธิ์การจำลองแบบทาสบน "testdb". * ถึง "การจำลอง"@"192.168.1.102" ระบุโดย "รหัสผ่าน";

รีบูต MySQL เพื่อให้การเปลี่ยนแปลงในการกำหนดค่ามีผล:
root@master# บริการ mysqld รีสตาร์ท

หากทุกอย่างเป็นไปด้วยดี คำสั่ง "show master status" ควรแสดงดังนี้:
mysql@master>แสดงสถานะมาสเตอร์\G
ไฟล์: mysql-bin.000003
ตำแหน่ง: 98
Binlog_Do_DB:
Binlog_Ignore_DB:
ค่าตำแหน่งควรเพิ่มขึ้นเมื่อมีการเปลี่ยนแปลงฐานข้อมูลบนต้นแบบ

การตั้งค่าการจำลอง

มาระบุ ID เซิร์ฟเวอร์ ชื่อของฐานข้อมูลสำหรับการจำลอง และเส้นทางไปยังรีเลย์บินล็อกในส่วนการกำหนดค่า จากนั้นโหลด MySQL อีกครั้ง:
เซิร์ฟเวอร์-id = 2
รีเลย์-log = /var/lib/mysql/mysql-relay-bin
รีเลย์บันทึกดัชนี = /var/lib/mysql/mysql-relay-bin.index
ทำซ้ำ-do-db = testdb

Root@replica# บริการ mysqld รีสตาร์ท

กำลังถ่ายโอนข้อมูล

ที่นี่เราจะต้องล็อคฐานข้อมูลสำหรับการเขียน ในการดำเนินการนี้ คุณสามารถหยุดแอปพลิเคชันหรือใช้แฟล็ก read_only บนต้นแบบได้ (โปรดทราบ: แฟล็กนี้ไม่มีผลกับผู้ใช้ที่มีสิทธิ์ SUPER) หากเรามีตาราง MyISAM เรามา "ล้างตาราง" ด้วย:
mysql@master> ล้างตารางพร้อมล็อคการอ่าน;
mysql@master> SET GLOBAL read_only = เปิด;

มาดูสถานะของมาสเตอร์ด้วยคำสั่ง “แสดงสถานะมาสเตอร์” และจดจำค่าไฟล์และตำแหน่ง (หลังจากบล็อคมาสเตอร์สำเร็จแล้ว ไม่ควรเปลี่ยนแปลง):
ไฟล์: mysql-bin.000003
ตำแหน่ง: 98

เราดัมพ์ฐานข้อมูล และหลังจากการดำเนินการเสร็จสิ้น เราจะลบการล็อกของต้นแบบออก:
mysql@master> SET GLOBAL read_only = ปิด;

เราถ่ายโอนดัมพ์ไปยังเรพลิกาและกู้คืนข้อมูลจากมัน
ในที่สุด เราเริ่มการจำลองด้วยคำสั่ง “เปลี่ยนต้นแบบเป็น” และ “เริ่มทาส” และดูว่าทุกอย่างเป็นไปด้วยดีหรือไม่:
mysql@replica> เปลี่ยน MASTER เป็น MASTER_HOST = "192.168.1.101", MASTER_USER = "การจำลอง", MASTER_PASSWORD = "รหัสผ่าน", MASTER_LOG_FILE = "mysql-bin.000003", MASTER_LOG_POS = 98;
mysql@replica> เริ่มทาส;
เราใช้ค่าของ MASTER_LOG_FILE และ MASTER_LOG_POS จากต้นแบบ

มาดูกันว่าการจำลองเกิดขึ้นอย่างไรด้วยคำสั่ง "แสดงสถานะทาส":
mysql@replica> แสดงสถานะทาส\G
Slave_IO_State: กำลังรอให้มาสเตอร์ส่งกิจกรรม
มาสเตอร์_โฮสต์: 192.168.1.101
Master_User: การจำลองแบบ
มาสเตอร์_พอร์ต: 3306
เชื่อมต่อ_ลองอีกครั้ง: 60
Master_Log_File: mysql-bin.000003
Read_Master_Log_Pos: 98
Relay_Log_File: mysql-relay-bin.001152
Relay_Log_Pos: 235
Relay_Master_Log_File: mysql-bin.000003
Slave_IO_Running: ใช่
Slave_SQL_Running: ใช่
Replicate_Do_DB: testdb, testdb
ทำซ้ำ_Ignore_DB:
ทำซ้ำ_Do_Table:
Replicate_Ignore_Table:
ทำซ้ำ_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
ข้าม_เคาน์เตอร์: 0
Exec_Master_Log_Pos: 98
รีเลย์_ล็อก_สเปซ: 235
จนกระทั่ง_เงื่อนไข: ไม่มี
จนกระทั่ง_Log_ไฟล์:
จนถึง_Log_Pos: 0
Master_SSL_Allowed: ไม่
Master_SSL_CA_ไฟล์:
มาสเตอร์_SSL_CA_เส้นทาง:
มาสเตอร์_SSL_ใบรับรอง:
มาสเตอร์_SSL_Cipher:
มาสเตอร์_SSL_คีย์:
Seconds_Behind_Master: 5

ฉันได้เน้นถึงคุณค่าที่น่าสนใจที่สุดแล้ว หากการจำลองเริ่มต้นได้สำเร็จ ค่าควรใกล้เคียงกับในรายการ (ดูคำอธิบายของคำสั่ง "แสดงสถานะทาส" ในเอกสารประกอบ) ค่า Seconds_Behind_Master สามารถเป็นจำนวนเต็มใดก็ได้
หากการจำลองแบบเป็นเรื่องปกติ แบบจำลองจะตามต้นแบบ (หมายเลขบันทึกใน Master_Log_File และตำแหน่ง Exec_Master_Log_Pos จะเพิ่มขึ้น) เวลาล่าช้าของแบบจำลองจากต้นแบบ (Seconds_Behind_Master) ควรเท่ากับศูนย์ หากไม่ลดลงหรือเพิ่มขึ้น อาจเป็นไปได้ว่าโหลดบนเรพลิกาสูงเกินไป - ไม่มีเวลาทำซ้ำการเปลี่ยนแปลงที่เกิดขึ้นกับต้นแบบ
ถ้า Slave_IO_State ว่างเปล่า และ Seconds_Behind_Master เป็น NULL การจำลองแบบยังไม่เริ่มต้น ดูบันทึก MySQL เพื่อค้นหาสาเหตุ ลบออก และเริ่มการจำลองใหม่:
mysql@replica> เริ่มทาส;

ด้วยขั้นตอนง่ายๆ เหล่านี้ เราจะได้รับแบบจำลองที่มีข้อมูลเหมือนกับข้อมูลบนต้นแบบ
อย่างไรก็ตาม เวลาที่มาสเตอร์ถูกบล็อคคือเวลาที่ดัมพ์ถูกสร้างขึ้น หากใช้เวลานานในการสร้าง คุณสามารถลองทำสิ่งนี้:

• บล็อกการเขียนถึงต้นแบบด้วยแฟล็ก read_only จำตำแหน่งและหยุด MySQL
• หลังจากนั้น ให้คัดลอกไฟล์ฐานข้อมูลไปยังเรพลิกาและเปิดใช้งานไฟล์ต้นแบบ
• เริ่มการจำลองแบบตามปกติ

มีหลายวิธีในการสร้างเรพลิกาโดยไม่ต้องหยุดต้นแบบเลย แต่ก็ไม่ได้ผลเสมอไป

การเพิ่มแบบจำลอง

สมมติว่าเรามีต้นแบบและแบบจำลองที่ใช้งานได้อยู่แล้ว และเราจำเป็นต้องเพิ่มอีกอันหนึ่งเข้าไป ซึ่งทำได้ง่ายกว่าการเพิ่มเรพลิกาแรกให้กับต้นแบบ และสิ่งที่ดีกว่ามากคือไม่จำเป็นต้องหยุดอาจารย์ในเรื่องนี้
ขั้นแรก มากำหนดค่า MySQL บนแบบจำลองที่สอง และตรวจสอบให้แน่ใจว่าเราได้ป้อนแล้ว พารามิเตอร์ที่จำเป็นในการกำหนดค่า:
เซิร์ฟเวอร์-id = 3
ทำซ้ำ-do-db = testdb

ตอนนี้เรามาหยุดการจำลองแบบในการจำลองครั้งแรก:
mysql@replica-1> หยุดทาส;

แบบจำลองจะยังคงทำงานได้ตามปกติ แต่ข้อมูลในแบบจำลองจะไม่เป็นปัจจุบันอีกต่อไป มาดูสถานะและจำตำแหน่งหลักที่เรพลิกาไปถึงก่อนที่จะหยุดการจำลอง:
mysql@replica-1> แสดงสถานะทาส\G

ค่าที่เราต้องการคือ Master_Log_File และ Exec_Master_Log_Pos:
Master_Log_File: mysql-bin.000004
Exec_Master_Log_Pos: 155

มาสร้างดัมพ์ฐานข้อมูลและจำลองแบบต่อในแบบจำลองแรก:
mysql@replica-1> เริ่มทาส;

มาคืนค่าข้อมูลจากดัมพ์บนเรพลิกาที่สองกัน จากนั้นเปิดใช้งานการจำลองแบบ:
mysql@replica-2> เปลี่ยน MASTER เป็น MASTER_HOST = "192.168.1.101", MASTER_USER = "การจำลอง", MASTER_PASSWORD = "รหัสผ่าน", MASTER_LOG_FILE = "mysql-bin.000004", MASTER_LOG_POS = 155;
mysql@replica-2> เริ่มทาส;

ค่า MASTER_LOG_FILE และ MASTER_LOG_POS คือค่า Master_Log_File และ Exec_Master_Log_Pos ตามลำดับ จากผลลัพธ์ของคำสั่ง “แสดงสถานะทาส” ในเรพลิกาแรก
การจำลองแบบต้องเริ่มต้นจากตำแหน่งที่แบบจำลองแรกถูกหยุด (และตามนั้น มีการสร้างดัมพ์) ดังนั้นเราจะมีแบบจำลองสองชุดที่มีข้อมูลที่เหมือนกัน

การรวมแบบจำลอง

บางครั้งสถานการณ์ต่อไปนี้เกิดขึ้น: มีสองฐานข้อมูลบนต้นแบบ ซึ่งหนึ่งในนั้นจะถูกจำลองแบบบนแบบจำลองหนึ่ง และฐานข้อมูลที่สองอยู่บนอีกแบบจำลอง วิธีการตั้งค่าการจำลองแบบของฐานข้อมูลทั้งสองบนแบบจำลองทั้งสองโดยไม่ต้องทิ้งลงบนต้นแบบหรือปิดระบบ ค่อนข้างง่ายโดยใช้คำสั่ง "startทาสจนกระทั่ง"
ดังนั้นเราจึงมีต้นแบบที่มีฐานข้อมูล testdb1 และ testdb2 ซึ่งจำลองแบบบนแบบจำลอง Replica-1 และ Replica-2 ตามลำดับ มากำหนดค่าการจำลองแบบของฐานข้อมูลทั้งสองเป็นแบบจำลอง 1 โดยไม่หยุดต้นแบบ
หยุดการจำลองบน Replica-2 ด้วยคำสั่งและจดจำตำแหน่งของต้นแบบ:
mysql@replica-2> หยุดทาส;
mysql@replica-2> แสดงสถานะทาส\G
Master_Log_File: mysql-bin.000015
Exec_Master_Log_Pos: 231

มาสร้างดัมพ์ของฐานข้อมูล testdb2 และดำเนินการจำลองต่อ (ซึ่งเสร็จสิ้นการจัดการด้วย Replica-2) เราจะคืนค่าดัมพ์เป็นแบบจำลอง-1

สถานการณ์บน Replica-1 เป็นเช่นนี้: ฐานข้อมูล testdb1 อยู่ที่ตำแหน่งหลักหนึ่งตำแหน่งและยังคงทำซ้ำต่อไป ฐานข้อมูล testdb2 ได้รับการกู้คืนจากดัมพ์จากตำแหน่งอื่น มาซิงโครไนซ์กัน

หยุดการจำลองแบบและจดจำตำแหน่งของต้นแบบ:
mysql@replica-1> หยุดทาส;
mysql@replica-1> แสดงสถานะทาส\G
Exec_Master_Log_Pos: 501

ตรวจสอบให้แน่ใจว่าในการกำหนดค่าสำหรับ Replica-1 ชื่อของฐานข้อมูลที่สองระบุไว้ในส่วน:
ทำซ้ำ-do-db = testdb2

มารีบูต MySQL เพื่อให้การเปลี่ยนแปลงในการกำหนดค่ามีผล อย่างไรก็ตาม มันเป็นไปได้ที่จะรีสตาร์ท MySQL โดยไม่ต้องหยุดการจำลอง - จากบันทึกเราจะรู้ว่าตำแหน่งใดในการจำลองหลักที่หยุดลง

ตอนนี้เรามาจำลองจากตำแหน่งที่ Replica-2 หยุดชั่วคราวไปยังตำแหน่งที่เราเพิ่งหยุดการจำลองชั่วคราว:
mysql@replica-1> เปลี่ยน MASTER เป็น MASTER_HOST = "192.168.1.101", MASTER_USER = "การจำลอง", MASTER_PASSWORD = "รหัสผ่าน", MASTER_LOG_FILE = "mysql-bin.000015", MASTER_LOG_POS = 231;
mysql@replica-1> เริ่มทาสจนถึง MASTER_LOG_FILE = "mysql-bin.000016 ", MASTER_LOG_POS = 501;

การจำลองจะสิ้นสุดทันทีที่แบบจำลองถึงตำแหน่งที่ระบุในส่วนจนถึง หลังจากนั้นฐานข้อมูลทั้งสองของเราจะสอดคล้องกับตำแหน่งหลักเดียวกัน (ซึ่งเราหยุดการจำลองบนแบบจำลอง-1) มาตรวจสอบสิ่งนี้กัน:
mysql@replica-1> แสดงสถานะทาส\G
mysql@replica-1> เริ่มทาส;
Master_Log_File: mysql-bin.000016
Exec_Master_Log_Pos: 501

มาเพิ่มชื่อของทั้งสองฐานข้อมูลในการกำหนดค่าสำหรับแบบจำลอง-1 ในส่วน:
ทำซ้ำ-do-db = testdb1
ทำซ้ำ-do-db = testdb2

สิ่งสำคัญ: แต่ละฐานข้อมูลจะต้องอยู่ในรายการแยกบรรทัด
รีสตาร์ท MySQL และจำลองแบบต่อ:
mysql@replica-1> เปลี่ยน MASTER เป็น MASTER_HOST = "192.168.1.101", MASTER_USER = "การจำลอง", MASTER_PASSWORD = "รหัสผ่าน", MASTER_LOG_FILE = "mysql-bin.000016", MASTER_LOG_POS = 501;
หลังจากที่แบบจำลอง 1 ติดต่อกับต้นแบบแล้ว เนื้อหาของฐานข้อมูลจะเหมือนกัน คุณสามารถผสานฐานข้อมูลเข้ากับ Replica-2 ได้ด้วยวิธีที่คล้ายกัน หรือโดยการสร้างดัมพ์ของ Replica-1 โดยสมบูรณ์

ต้นแบบการหล่อและแบบจำลอง

อาจจำเป็นต้องสลับเรพลิกาเป็นโหมดมาสเตอร์ เช่น ในกรณีที่มาสเตอร์ล้มเหลวหรือเมื่อดำเนินการ งานด้านเทคนิค- เพื่อให้สวิตช์ดังกล่าวเป็นไปได้ คุณต้องกำหนดค่าเรพลิกาเหมือนต้นแบบหรือสร้างมันขึ้นมา ต้นแบบที่ไม่โต้ตอบ.

มาเปิดใช้งานการบันทึกไบนารี (นอกเหนือจากการถ่ายทอด binlogs) ในการกำหนดค่าในส่วน:
log-bin = /var/lib/mysql/mysql-bin

และเพิ่มผู้ใช้สำหรับการจำลองแบบ:
mysql@master> ให้สิทธิ์การจำลองแบบทาสบน 'testdb'. * ถึง 'การจำลอง'@'192.168.1.101′ ระบุโดย "รหัสผ่าน";

ต้นแบบแบบพาสซีฟดำเนินการจำลองแบบเหมือนกับแบบจำลองทั่วไป แต่นอกเหนือจากนั้นยังสร้างบันทึกไบนารี - นั่นคือเราสามารถเริ่มการจำลองแบบจากแบบจำลองนั้นได้ มาตรวจสอบสิ่งนี้ด้วยคำสั่ง "show master status":
mysql@replica> แสดงสถานะหลัก\G
ไฟล์: mysql-bin.000001
ตำแหน่ง: 61
Binlog_Do_DB:
Binlog_Ignore_DB:

ในตอนนี้ หากต้องการเปลี่ยนพาสซีฟมาสเตอร์เป็นโหมดแอคทีฟ คุณจะต้องหยุดการจำลองบนมาสเตอร์นั้นและเปิดใช้งานการจำลองบนต้นแบบที่ใช้งานอยู่เดิม เพื่อให้แน่ใจว่าข้อมูลจะไม่สูญหายในขณะที่เปลี่ยน ต้นแบบที่ใช้งานอยู่จะต้องล็อคการเขียน
mysql@master> ล้างตารางพร้อมล็อคการอ่าน
mysql@master> SET GLOBAL read_only = เปิด;
mysql@replica> หยุดทาส;
mysql@replica> แสดงสถานะหลัก;
ไฟล์: mysql-bin.000001
ตำแหน่ง: 61
mysql@master> เปลี่ยน MASTER เป็น MASTER_HOST = "192.168.1.102", MASTER_USER = "การจำลอง", MASTER_PASSWORD = "รหัสผ่าน", MASTER_LOG_FILE = "mysql-bin.000001", MASTER_LOG_POS = 61;
mysql@master> เริ่มทาส;
เพียงเท่านี้เราก็ได้เปลี่ยนต้นแบบที่ใช้งานอยู่ คุณสามารถลบบล็อกออกจากต้นแบบเดิมได้

บทสรุป

เราได้เรียนรู้เพียงเล็กน้อยเกี่ยวกับวิธีตั้งค่าการจำลองแบบใน MySQL และดำเนินการขั้นพื้นฐานบางอย่าง ขออภัย คำถามสำคัญต่อไปนี้อยู่นอกขอบเขตของบทความนี้:

• กำจัดจุดล้มเหลวจุดเดียว (SPF, จุดล้มเหลวจุดเดียว) เมื่อใช้เซิร์ฟเวอร์ MySQL เครื่องเดียว ความล้มเหลวทำให้เกิดความล้มเหลวของทั้งระบบ เมื่อใช้เซิร์ฟเวอร์หลายเครื่อง ความล้มเหลวของเซิร์ฟเวอร์ใดเซิร์ฟเวอร์หนึ่งจะส่งผลให้ระบบล้มเหลว เว้นแต่เราจะดูแลเรื่องนี้โดยเฉพาะ เราจำเป็นต้องจัดเตรียมการจัดการสถานการณ์ด้วยความล้มเหลวของต้นแบบและแบบจำลอง หนึ่งในเครื่องมือที่มีอยู่คือ MMM อย่างไรก็ตาม ต้องมีการแก้ไขไฟล์
• โหลดบาลานซ์ เมื่อใช้แบบจำลองหลายรายการ เราต้องการใช้กลไกการปรับสมดุลที่โปร่งใส โดยเฉพาะอย่างยิ่งหากประสิทธิภาพของแบบจำลองไม่สม่ำเสมอ สำหรับ Linux คุณสามารถใช้โซลูชันมาตรฐาน - LVS ได้
• การเปลี่ยนตรรกะของแอปพลิเคชัน ในสถานการณ์ที่เหมาะสม ควรส่งคำขออ่านข้อมูลไปยังเรพลิกา และควรส่งคำขอเปลี่ยนแปลงข้อมูลไปยังต้นแบบ อย่างไรก็ตาม เนื่องจากความล่าช้าของเรพลิกาที่เป็นไปได้ รูปแบบดังกล่าวมักจะไม่ได้ผล และจำเป็นต้องระบุคำขออ่านดังกล่าวที่ยังคงต้องดำเนินการบนต้นแบบ

ฉันหวังว่าจะครอบคลุมประเด็นเหล่านี้ในบทความต่อๆ ไป
ขอขอบคุณสำหรับความสนใจของคุณ!