การจำลองแบบ Mysql ของหลายฐานข้อมูล การจำลองแบบใน MySQL คืออะไร? เราดำเนินการเพิ่มเติมบนเซิร์ฟเวอร์ Slave
การจำลองข้อมูล mysqlช่วยให้คุณมีสำเนาฐานข้อมูลที่ถูกต้องจากเซิร์ฟเวอร์เดียว - เซิร์ฟเวอร์หลัก (เซิร์ฟเวอร์ชั้นนำ) บนเซิร์ฟเวอร์อื่นตั้งแต่หนึ่งเซิร์ฟเวอร์ขึ้นไป (เซิร์ฟเวอร์รอง) ตามค่าเริ่มต้น การจำลองแบบ Mysql เป็นแบบอะซิงโครนัส
ซึ่งหมายความว่าเซิร์ฟเวอร์หลักไม่มีการควบคุมและไม่ทราบว่าเซิร์ฟเวอร์ทาสกำลังอ่านไฟล์บันทึกหรือไม่และทำอย่างถูกต้องหรือไม่
นอกจากนี้ยังมีการซิงโครไนซ์ประเภทอื่นๆ แบบซิงโครนัสและกึ่งซิงโครนัสซึ่งมีการควบคุมกระบวนการเหล่านี้
ขึ้นอยู่กับการตั้งค่า คุณสามารถจำลองทั้งฐานข้อมูลทั้งหมดและตารางฐานข้อมูลแต่ละตารางได้
คุณสามารถใช้การจำลองเพื่ออะไร:
1. การกระจายโหลดระหว่างโฮสต์เพื่อปรับปรุงประสิทธิภาพ
ในรูปแบบดังกล่าว โหนดหลักจะดำเนินการอ่านและเขียน โหนดที่มีการสมัครสมาชิกกับโหนดหลักจะจัดเตรียมฐานสำหรับการอ่าน ดังนั้น เราจะบรรเทาเซิร์ฟเวอร์หลักจากการดำเนินการอ่าน
2. ความปลอดภัยของข้อมูลและความง่ายในการบำรุงรักษา เนื่องจากโหนดทาสมีข้อมูลแบบอ่านอย่างเดียว การเปลี่ยนแปลงข้อมูลในผู้สมัครสมาชิกจะถูกจำกัด ความง่ายในการบำรุงรักษา - ความสามารถในการรันกระบวนการที่ให้บริการฐานข้อมูลโดยไม่รบกวนการทำงานของแอปพลิเคชัน
3. การกระจายข้อมูลในระยะทางไกล คุณสามารถสร้างสำเนาข้อมูลบนโฮสต์ใดก็ได้ โดยไม่คำนึงถึงตำแหน่งของโฮสต์
mysqlรองรับวิธีการจำลองแบบต่อไปนี้:
แบบดั้งเดิม - วิธีการนี้จะขึ้นอยู่กับการจำลองเหตุการณ์จากไฟล์บันทึกไบนารีของต้นแบบ และต้องใช้ไฟล์บันทึก ตำแหน่งระหว่างเซิร์ฟเวอร์หลักและเซิร์ฟเวอร์ทาสจะต้องซิงโครไนซ์
วิธีการใช้ตัวระบุธุรกรรมทั่วโลก GTID (วิธีการทำธุรกรรม)
mysqlรองรับการซิงโครไนซ์ประเภทต่อไปนี้:
อะซิงโครนัส (การซิงโครไนซ์ทางเดียว)
กึ่งซิงโครนัส (การควบคุมสมาชิกบางส่วน)
ซิงโครนัส (ควบคุมสมาชิกเต็มรูปแบบ)
การตั้งค่าการจำลองฐานข้อมูล Mysql ด้วยวิธีการดั้งเดิม
หลักการทำงาน
เซิร์ฟเวอร์หลักประกอบด้วย ถังขยะไฟล์บันทึกซึ่งบันทึกการเปลี่ยนแปลงทั้งหมดที่เกิดขึ้นในฐานข้อมูลหลัก ซึ่งเป็นไฟล์ที่อธิบายชื่อ ถังขยะรวมถึงตำแหน่งในบันทึกที่บันทึกข้อมูลหลักล่าสุด
โหนดทาสได้รับข้อมูลจากต้นแบบที่มีข้อมูลเกี่ยวกับชื่อ ถังขยะไฟล์และตำแหน่งในไฟล์บันทึก
การตั้งค่าตัวช่วยสร้าง
my.iniต้องมีตัวระบุที่ไม่ซ้ำกัน - ตัวเลขตั้งแต่ 1 ถึง 2 ถึงกำลังที่ 32 - 1, server-id
ตามค่าเริ่มต้น server-id=0 ซึ่งหมายความว่าไม่ยอมรับการสมัครสมาชิกจากเซิร์ฟเวอร์ทาส
log-bin=mysql-bin
เซิร์ฟเวอร์-id=1
สองบรรทัดนี้เพียงพอที่จะเริ่มต้น
หมายเหตุ: อย่างไรก็ตาม หากใช้ InnoDB ขอแนะนำให้เพิ่มเพิ่มเติม
innodb_flush_log_at_trx_commit=1
sync_binlog=1
และคุณต้องตรวจสอบว่าไม่ได้ปิดใช้งานความสามารถในการทำงานกับเครือข่ายและมีการตั้งค่าพารามิเตอร์ข้ามเครือข่าย
เซิร์ฟเวอร์ทาสเชื่อมต่อกับเซิร์ฟเวอร์หลักโดยใช้ชื่อผู้ใช้และรหัสผ่าน ดังนั้นเราจึงสร้างผู้ใช้บนเซิร์ฟเวอร์หลักก่อน
สร้างผู้ใช้ repl@%.mydomain.com ระบุโดยทาสพาส;
ให้สิทธิ์การจำลองแบบทาสบน *.* เพื่อ repl@%.mydomain.com;
มาดูสภาพกัน
แสดงสถานะมาสเตอร์
หากขั้นตอนการสร้างบันทึกไบนารีได้เปิดใช้งานแล้ว สำหรับตาราง InnoDB คุณต้องล็อคตารางในเซสชันใดเซสชันหนึ่งก่อน
ล้างตารางพร้อมล็อคการอ่าน;
หากคุณออกจากเซสชั่น การล็อคตารางจะถูกปลดล็อคโดยอัตโนมัติ
ในอีกเซสชันหนึ่ง เราได้รับค่าชื่อ ถังขยะบันทึกและตำแหน่ง
ทั้งสองค่าแสดงถึงพิกัดการจำลองที่เซิร์ฟเวอร์ทาสต้องเริ่มอ่านจากไฟล์ในตำแหน่งที่ต้องการเพื่อเริ่มการจำลองแบบ
ขั้นตอนต่อไปขึ้นอยู่กับว่ามีข้อมูลบนเซิร์ฟเวอร์ทาสหรือไม่หรือข้อมูลจากต้นแบบ
หากมีอยู่ เราก็ปล่อยให้ตารางถูกล็อคและสร้างขึ้นมา ถ่ายโอนข้อมูล(นี่เป็นวิธีที่แนะนำเมื่อใช้ InnoDB)
คุณสามารถค้นหาประเภทฐานข้อมูลได้ด้วยคำสั่ง
mysqlshow -u mysql_user -p -i ชื่อฐานข้อมูล
หากฐานข้อมูลถูกจัดเก็บไว้ในไฟล์ไบนารี ฐานข้อมูลเหล่านั้นก็สามารถคัดลอกจากฐานข้อมูลหลักไปยังเซิร์ฟเวอร์รองได้
มาทำกันเถอะ ถ่ายโอนข้อมูล
mysqldump --ฐานข้อมูลทั้งหมด --master-data dbdump.db
เพื่อเลือกฐาน mysqldump --ฐานข้อมูล --master-data dbdump.db
พารามิเตอร์ข้อมูลหลักจะเพิ่มโดยอัตโนมัติ เปลี่ยนมาสเตอร์เป็นบนโหนดทาส หากไม่ได้เพิ่มพารามิเตอร์ ตารางทั้งหมดในเซสชันจะต้องถูกล็อคด้วยตนเอง
ปลดล็อค
ปลดล็อคตาราง;
การกำหนดค่าโหนดทาสก
เพิ่ม my.ini server-id จากส่วนบุคคลจากต้นแบบและจากโหนดอื่น
เซิร์ฟเวอร์-id=2
สร้างการสมัครสมาชิก
เปลี่ยนมาสเตอร์เป็น
MASTER_HOST=มาสเตอร์_โฮสต์_ชื่อ
MASTER_USER=replication_user_name,
MASTER_PASSWORD=รหัสผ่านการจำลองแบบ,
MASTER_LOG_FILE=recorded_log_file_name,
MASTER_LOG_POS=บันทึก_log_ตำแหน่ง;
เมื่อตั้งค่าการจำลองด้วยข้อมูลที่มีอยู่ คุณต้องถ่ายโอนสแน็ปช็อตจากต้นแบบไปยังสเลฟก่อนที่การจำลองจะเริ่มขึ้น
เราใช้ mysqldump
1.เริ่มโหนดทาสโดยใช้ --ข้ามทาสเริ่มต้นพารามิเตอร์เพื่อป้องกันการจำลองไม่ให้เริ่มทำงาน
2. นำเข้าไฟล์ดัมพ์
mysql fulldb.dump
3. เริ่มขั้นตอนการสมัครสมาชิก
เริ่มทาส;
การตรวจสอบสถานะการจำลอง
แสดงสถานะทาส\G
Slave_IO_State: - สถานะปัจจุบันของอุปกรณ์ทาส
Slave_IO_Running: - ไม่ว่าสตรีมข้อมูลจากต้นแบบจะอ่านหรือไม่
Slave_SQL_Running: - พวกมันกำลังทำงานอยู่หรือเปล่า? แบบสอบถาม SQLควรจะใช่
ตัวอย่างมากำหนดค่าเซิร์ฟเวอร์ Master (มาสเตอร์) – ip 11.11.11.10 V my.ini
[
mysqld] log-bin=mysql-bin server-id=1
สร้างผู้ใช้ mysql -u root -p GRANT REPLICATION SLAVE ON *.* เพื่อจำลอง@% ระบุด้วยรหัสผ่าน; สิทธิ์ล้าง;
ต่อไปเราจะล็อคตารางทั้งหมดในฐานข้อมูล ล้างตารางพร้อมล็อคการอ่าน;
เราดูที่สถานะ แสดงสถานะมาสเตอร์;
เราจำชื่อไฟล์และตำแหน่งได้ เราจะใช้มันบนเซิร์ฟเวอร์ Slave เพื่อสมัครสมาชิก
บนทาสบี my.ini
log-bin=mysql-bin เซิร์ฟเวอร์-id=2
สร้างการสมัครสมาชิก เปลี่ยนมาสเตอร์เป็น MASTER_HOST=11.11.11.10, MASTER_PORT=3306,
MASTER_USER=แบบจำลอง, MASTER_PASSWORD=รหัสผ่าน,
MASTER_LOG_FILE=เซิร์ฟเวอร์-mysql-bin.000002,
MASTER_LOG_POS=1151664, MASTER_CONNECT_RETRY=10;
เริ่มทาส;
สถานะการจำลองแบบ แสดงสถานะทาส\G
คำว่าการจำลองใช้เพื่ออ้างถึงกลไกในการซิงโครไนซ์ข้อมูลหลายชุด ซึ่งจะเพิ่มความปลอดภัยของข้อมูล ความทนทานต่อข้อผิดพลาด และประสิทธิภาพของระบบ ตัวอย่างที่ชัดเจนคือการจำลองฐานข้อมูลระหว่างเซิร์ฟเวอร์สองเครื่อง
การจำลองแบบ MySQL Master-Slave
ในคำศัพท์เฉพาะทาง Master-Slave Master คือเซิร์ฟเวอร์หลักที่มีฐานข้อมูล โดยจะเขียนไปยังฐานข้อมูล แต่การอ่านจะถูกกระจายระหว่าง Master และ Slave ขึ้นอยู่กับโหลดบนระบบ ซึ่งจะเพิ่มความทนทานต่อข้อผิดพลาดและประสิทธิภาพ นอกจากนี้ ด้วยแนวทางนี้ สำเนาของฐานข้อมูลจึงพร้อมเสมอและสามารถกู้คืนได้หากเซิร์ฟเวอร์ตัวใดตัวหนึ่งล้มเหลว
ในสถานการณ์ใดบ้างที่อาจจำเป็นต้องใช้เซิร์ฟเวอร์ทาส? ตัวอย่างเช่น เมื่ออาร์เรย์ข้อมูลจำนวนมากมาถึงเพื่อเขียนลงในฐานข้อมูล และเซิร์ฟเวอร์หลักก็ไม่มีเวลาอ่าน และไคลเอ็นต์ต้องรอการสิ้นสุดการเขียน ซึ่งสามารถหลีกเลี่ยงได้เนื่องจากเซิร์ฟเวอร์ทาส
สถานการณ์เป็นไปได้เมื่อเซิร์ฟเวอร์หลักล้มเหลว ในกรณีนี้ เซิร์ฟเวอร์ทาสจะเข้าควบคุมฟังก์ชันทั้งหมดของเซิร์ฟเวอร์หลักและทำงานเพียงลำพังจนกว่าจะได้รับการกู้คืน ลูกค้ามักจะไม่สังเกตเห็นอะไรเลย และแน่นอนว่าเขาจะไม่รอสักหนึ่งหรือสองหรือสามชั่วโมงเพื่อให้ช่างเทคนิคแก้ไข
การตั้งค่าการจำลองแบบไม่ใช่เรื่องยากเลย เนื่องจากกลไกนี้ถูกสร้างขึ้นใน MySQL ตั้งแต่เริ่มต้น
การตั้งค่าบนเซิร์ฟเวอร์หลัก
เริ่มต้นด้วยการแก้ไขไฟล์การกำหนดค่า my.cnf ซึ่งส่วนใหญ่อยู่ที่ /etc/mysql/my.cnf คุณต้องค้นหาและไม่ใส่เครื่องหมายข้อคิดเห็น (ลบ #) หรือเขียนบรรทัดดังกล่าว
Bind-address = 0.0.0.0 server-id = 1 log_bin = /var/log/mysql/mysql-bin.log
สำคัญ! หากมีการลงทะเบียนที่อยู่ผูกไว้แล้ว จะต้องเปลี่ยนแปลง ไม่เช่นนั้นจะไม่สามารถสร้างการเชื่อมต่อระหว่างเซิร์ฟเวอร์ได้
หลังจากนี้เราจะรีสตาร์ทฐานข้อมูลบนเซิร์ฟเวอร์ทันที
/etc/init.d/mysql รีสตาร์ท
ตอนนี้เราจำเป็นต้องสร้างผู้ใช้ที่มีสิทธิ์ในการจำลองฐานข้อมูลของเรา ซึ่งสามารถทำได้ตั้งแต่รูทอิน คอนโซล MySQLโดยใช้คำสั่ง
ให้สิทธิ์การจำลอง SLAVE บน *.* ถึง "slave_user"@"%" ระบุโดย "slave_password"; สิทธิ์ล้าง;
โดยที่แทนที่จะเป็น "slave_user" และ "slave_password" คุณต้องเขียนข้อมูลเข้าสู่ระบบและรหัสผ่านสำหรับทาส
ตอนนี้เรามาดูข้อมูลหลักกัน
แสดงสถานะมาสเตอร์;
ค่าคอลัมน์ ไฟล์ และ ตำแหน่ง คุณต้องจำไว้ว่า พวกมันจะถูกใช้ในการตั้งทาส ซึ่งเป็นสิ่งที่เรากำลังดำเนินการอยู่ตอนนี้
การตั้งค่าบนเซิร์ฟเวอร์ Slave
ขั้นตอนแรกคือการสร้างฐานข้อมูลที่มีชื่อเดียวกับฐานข้อมูลที่เราจะทำซ้ำ นี่เป็นขั้นตอนสำคัญและไม่ควรละเลย จากนั้นไปที่ไฟล์กำหนดค่าที่เราคุ้นเคยอยู่แล้ว my.cnf และเขียนการตั้งค่า
Server-id = 2 รีเลย์ล็อก = /var/log/mysql/mysql-relay-bin.log bin-log = /var/log/mysql/mysql-bin.log
สำคัญ! ใน bin-log เส้นทางไปยัง bin-log จะถูกเขียน บนเซิร์ฟเวอร์เมสเตอร์ . รหัสเซิร์ฟเวอร์จะต้องแตกต่างจากรหัสหลัก จึงสะดวกในการตั้งค่าเป็น 1 เพิ่มเติม
เปลี่ยน MASTER เป็น MASTER_HOST="1.1.1.1", MASTER_USER="slave_user", MASTER_PASSWORD="slave_password", MASTER_LOG_FILE = "mysql-bin.000001", MASTER_LOG_POS = 107; เริ่มทาส;
โดยที่โฮสต์คือที่อยู่ IP ของต้นแบบ การเข้าสู่ระบบและรหัสผ่านสอดคล้องกับที่เราสร้างบนต้นแบบ master_log_file และ master_log_pos จะถูกกรอกด้วยข้อมูลจาก รายการสุดท้ายสำหรับการกำหนดค่าเซิร์ฟเวอร์หลัก .
นับจากนี้เป็นต้นไป การเปลี่ยนแปลงทั้งหมดในฐานข้อมูลจะถูกโอนจากต้นแบบไปยังสเลฟ
กำลังตรวจสอบสถานะการจำลอง
นอกเหนือจากคำสั่ง SHOW MASTER STATUS; มีสิ่งที่คล้ายกันสำหรับทาส SHOW SLAVE STATUS\G ซึ่งจะแสดงตารางพร้อมข้อมูล สัญญาณหลักที่เซิร์ฟเวอร์เชื่อมต่อและทำงานอย่างถูกต้องคือการมีบรรทัดดังกล่าว
การจำลองแบบ- เทคนิคที่ใช้ในสถาปัตยกรรมของระบบที่ทำงานภายใต้โหลด ซึ่งผลลัพธ์คือการกระจายโหลดเมื่อทำงานกับฐานข้อมูลเดียวผ่านเซิร์ฟเวอร์หลายเครื่อง การจำลองแบบ MySQL MASTER SLAVE ถูกใช้บ่อยกว่า แต่ก็มีการใช้การจำลองแบบประเภทที่สองเช่นกัน - Master-Master
การจำลองแบบ MySQL MASTER SLAVE คืออะไร และใช้เพื่ออะไร
การจำลองแบบ มาสเตอร์-สเลฟเกี่ยวข้องกับการทำซ้ำข้อมูลไปยังเซิร์ฟเวอร์ MySQL ทาส การทำซ้ำดังกล่าวส่วนใหญ่ดำเนินการเพื่อให้มั่นใจในความน่าเชื่อถือ หากเซิร์ฟเวอร์หลักล้มเหลว ฟังก์ชั่นจะถูกสลับไปที่ทาส
การจำลองแบบยังสามารถดำเนินการเพื่อปรับปรุงประสิทธิภาพของระบบได้ แต่ประสิทธิภาพมักเป็นเรื่องรองเสมอ
เมื่อแอปพลิเคชันทำงานกับฐานข้อมูล การดำเนินการที่พบบ่อยที่สุดคือ เลือก- การขออ่านข้อมูล แก้ไขข้อมูล - การร้องขอ ลบ, แทรก, อัปเดต, เปลี่ยนแปลงตามสถิติแล้วมันเกิดขึ้นน้อยกว่ามาก
เพื่อป้องกันข้อมูลสูญหายหากเซิร์ฟเวอร์ตัวใดตัวหนึ่งล้มเหลว การดำเนินการเพื่อเปลี่ยนแปลงข้อมูลในตารางจะถูกประมวลผลโดยเซิร์ฟเวอร์หลักเสมอ การเปลี่ยนแปลงจะถูกจำลองแบบไปยัง Slave การอ่านสามารถทำได้จากเซิร์ฟเวอร์ที่มีบทบาทเป็นทาส
ด้วยเหตุนี้คุณจึงสามารถได้รับประสิทธิภาพเพิ่มขึ้นพร้อมกับความน่าเชื่อถือ
โซลูชันนี้ได้รับความนิยม แต่อาจไม่สามารถใช้ได้เสมอไป เนื่องจากอาจมีความล่าช้าในระหว่างการจำลองแบบ - หากเกิดเหตุการณ์นี้ขึ้น จะต้องอ่านข้อมูลจากเซิร์ฟเวอร์หลักด้วย
การส่งคำขอบางประเภทไปยังเซิร์ฟเวอร์ฐานข้อมูลเฉพาะนั้นไม่ว่าในกรณีใดก็ตามจะถูกนำไปใช้ในระดับแอปพลิเคชัน
ถ้าทำการแบ่ง แบบสอบถามที่เลือกและส่วนที่เหลือทั้งหมดในระดับโปรแกรม โดยส่งไปยังเซิร์ฟเวอร์ที่ต้องการเมื่อหนึ่งในนั้นล้มเหลว แอปพลิเคชันที่โครงสร้างพื้นฐานให้บริการจะไม่สามารถใช้งานได้ เพื่อให้ได้ผล คุณต้องจัดหาข้อมูลเพิ่มเติม วงจรที่ซับซ้อนและจองเซิร์ฟเวอร์แต่ละเครื่อง
การจำลองมีไว้เพื่อความทนทานต่อข้อผิดพลาด ไม่ใช่เพื่อการปรับขนาด
การจำลองแบบ 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:ทาส_ผู้ใช้
มาสเตอร์_พอร์ต: 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_File:
จนถึง_Log_Pos: 0
Master_SSL_Allowed: ไม่
Master_SSL_CA_ไฟล์:
มาสเตอร์_SSL_CA_เส้นทาง:
มาสเตอร์_SSL_ใบรับรอง:
มาสเตอร์_SSL_Cipher:
มาสเตอร์_SSL_คีย์:
วินาที_หลัง_มาสเตอร์: 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 วินาที)
เนื่องจากไม่มีข้อผิดพลาดเกิดขึ้น เราจึงสามารถสรุปได้ว่ามีการกำหนดค่าการจำลองอย่างถูกต้อง
เป็น เครื่องมือที่ดีการปรับขนาด แต่ข้อเสียเปรียบหลักคือการไม่ซิงโครไนซ์การคัดลอกข้อมูลและความล่าช้าซึ่งอาจเป็นเรื่องสำคัญ
การใช้โซลูชันที่ทันสมัยกว่าทำให้คุณสามารถหลีกเลี่ยงปัญหาเหล่านี้ได้อย่างสมบูรณ์ ติดตั้งง่าย เชื่อถือได้ และไม่จำเป็นต้องคัดลอกดัมพ์ฐานข้อมูลด้วยตนเอง
ปัด 8 เมษายน 2552 เวลา 11:10 น
พื้นฐานการจำลองแบบ MySQL
- MySQL
ฉันเริ่มคุ้นเคยกับการจำลองแบบของเซิร์ฟเวอร์ MySQL เมื่อไม่นานนี้ และในขณะที่ฉันทำการทดลองต่างๆ กับการกำหนดค่า ฉันก็จดบันทึกสิ่งที่ใช้ได้ผลสำหรับฉัน เมื่อผมรวบรวมเนื้อหาได้ค่อนข้างมาก จึงมีแนวคิดที่จะเขียนบทความนี้ ฉันได้พยายามรวบรวมเคล็ดลับและวิธีแก้ปัญหาสำหรับปัญหาพื้นฐานที่สุดบางข้อที่ฉันพบ ฉันจะให้ลิงก์ไปยังเอกสารประกอบและแหล่งข้อมูลอื่นๆ ตลอดทาง ฉันไม่สามารถแกล้งทำเป็นอธิบายได้ทั้งหมด แต่ฉันหวังว่าบทความนี้จะมีประโยชน์
แนะนำสั้น ๆ
การจำลองแบบ (จากละติน replico - ฉันทำซ้ำ) คือการจำลองแบบของการเปลี่ยนแปลงข้อมูลจากเซิร์ฟเวอร์ฐานข้อมูลหลักไปยังเซิร์ฟเวอร์ที่ขึ้นต่อกันตั้งแต่หนึ่งเซิร์ฟเวอร์ขึ้นไป เราจะเรียกเซิร์ฟเวอร์หลัก ผู้เชี่ยวชาญและขึ้นอยู่กับ - แบบจำลอง.การเปลี่ยนแปลงข้อมูลที่เกิดขึ้นบนต้นแบบจะถูกทำซ้ำบนเรพลิกา (แต่ไม่ใช่ในทางกลับกัน) ดังนั้น การสืบค้นเพื่อเปลี่ยนแปลงข้อมูล (INSERT, UPDATE, DELETE ฯลฯ) จะถูกดำเนินการบนต้นแบบเท่านั้น ในขณะที่การสืบค้นเพื่ออ่านข้อมูล (หรืออีกนัยหนึ่งคือ SELECT) สามารถดำเนินการได้ทั้งบนแบบจำลองและต้นแบบ กระบวนการเรพลิเคชันบนเรพลิกาตัวใดตัวหนึ่งไม่ส่งผลต่อการทำงานของเรพลิกาอื่น และในทางปฏิบัติแล้วจะไม่ส่งผลกระทบต่อการทำงานของต้นแบบ
การจำลองแบบจะดำเนินการโดยใช้บันทึกไบนารีที่เก็บรักษาไว้บนต้นแบบ โดยจะจัดเก็บการสืบค้นทั้งหมดที่นำไปสู่ (หรืออาจนำไปสู่) การเปลี่ยนแปลงในฐานข้อมูล (การสืบค้นจะไม่ได้รับการบันทึกอย่างชัดเจน ดังนั้น หากคุณต้องการดู คุณจะต้องใช้ยูทิลิตี mysqlbinlog) binlogs จะถูกถ่ายโอนไปยังเรพลิกา (binlog ที่ดาวน์โหลดจากต้นแบบเรียกว่า "relay binlog") และการสืบค้นที่เก็บไว้จะถูกดำเนินการโดยเริ่มจากตำแหน่งที่แน่นอน สิ่งสำคัญคือต้องเข้าใจว่าในระหว่างการจำลองแบบ ไม่ใช่ข้อมูลที่เปลี่ยนแปลงเท่านั้นที่ถูกถ่ายโอน แต่เป็นเพียงคำขอที่ทำให้เกิดการเปลี่ยนแปลงเท่านั้น
ด้วยการจำลองแบบ เนื้อหาของฐานข้อมูลจะถูกทำซ้ำบนเซิร์ฟเวอร์หลายเครื่อง เหตุใดจึงต้องหันไปพึ่งการทำซ้ำ? มีสาเหตุหลายประการ:
- ประสิทธิภาพและความสามารถในการขยายขนาด. เซิร์ฟเวอร์เครื่องหนึ่งอาจไม่สามารถจัดการโหลดที่เกิดจากการดำเนินการอ่านและเขียนพร้อมกันในฐานข้อมูลได้ ประโยชน์ของการสร้างเรพลิกาจะยิ่งมีมากขึ้นตามการอ่านต่อการเขียนที่คุณมีในระบบของคุณมากขึ้น
- ความอดทนต่อความผิดพลาด. ในกรณีที่แบบจำลองล้มเหลว คำขออ่านทั้งหมดสามารถถ่ายโอนไปยังต้นแบบได้อย่างปลอดภัย หากต้นแบบล้มเหลว คำขอเขียนสามารถโอนไปยังเรพลิกาได้ (หลังจากที่ต้นแบบได้รับการกู้คืนแล้ว ก็สามารถเข้ามารับหน้าที่แทนเรพลิกาได้)
- การสำรองข้อมูล. แบบจำลองสามารถ "ช้าลง" ได้ชั่วขณะหนึ่งเพื่อดำเนินการ mysqldump แต่ต้นแบบไม่สามารถทำได้
- การคำนวณเลื่อนออกไป. การสืบค้น SQL ที่หนักและช้าสามารถดำเนินการบนเรพลิกาแยกต่างหากโดยไม่ต้องกลัวว่าจะรบกวนการทำงานปกติของทั้งระบบ
กำลังตั้งค่าการจำลอง
สมมติว่าเรามีฐานข้อมูลที่ใช้งานได้ ข้อมูลมายเอสคิวแอลกรอกข้อมูลและรวมไว้ในงานแล้ว และด้วยเหตุผลประการหนึ่งที่อธิบายไว้ข้างต้น เราจะเปิดใช้งานการจำลองแบบเซิร์ฟเวอร์ของเรา ข้อมูลเริ่มต้นของเรา:- ที่อยู่ 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_File:
จนถึง_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 ได้
- การเปลี่ยนตรรกะของแอปพลิเคชัน ในสถานการณ์ที่เหมาะสม ควรส่งคำขออ่านข้อมูลไปยังเรพลิกา และควรส่งคำขอเปลี่ยนแปลงข้อมูลไปยังต้นแบบ อย่างไรก็ตาม เนื่องจากความล่าช้าของเรพลิกาที่เป็นไปได้ รูปแบบดังกล่าวมักจะไม่ได้ผล และจำเป็นต้องระบุคำขออ่านดังกล่าวที่ยังคงต้องดำเนินการบนต้นแบบ
ขอขอบคุณสำหรับความสนใจของคุณ!
แท็ก:
- mysql
- การจำลองแบบ
ไม่นานมานี้ผมถูกขอให้พูดถึง การจำลองแบบใน MySQL. ฉันตัดสินใจว่าหัวข้อนี้อาจเป็นประโยชน์กับหลาย ๆ คนดังนั้นในบทความนี้ฉันจะพูดถึง การจำลองแบบใน MySQL คืออะไร จำเป็นเมื่อใด และจะกำหนดค่าอย่างไร.
ภารกิจหลักของการจำลองแบบคือ รวมพลังของเซิร์ฟเวอร์หลายตัว. สมมติว่าเว็บไซต์ของคุณมีเซิร์ฟเวอร์เฉพาะ แต่เมื่อเวลาผ่านไป มีผู้เยี่ยมชมมากและไม่สามารถทนต่อภาระงานได้อีกต่อไป ส่งผลให้เซิร์ฟเวอร์เริ่มช้าลงและหยุดทำงานเป็นประจำ วิธีที่ง่ายที่สุดคือซื้อเซิร์ฟเวอร์ที่ทรงพลังกว่านี้ และนี่คือสิ่งที่คนส่วนใหญ่ทำ แต่ไม่ช้าก็เร็วก็ถึงเวลาที่ต้นทุนในการเพิ่มราคาของเซิร์ฟเวอร์ไม่สอดคล้องกับประสิทธิภาพที่เพิ่มขึ้นดังนั้นจึงมีกำไรมากกว่าที่จะซื้อ 2 เซิร์ฟเวอร์ที่แตกต่างกันด้วยเงินน้อยลง
เป็นผลให้ฐานข้อมูลของคุณอยู่บนเซิร์ฟเวอร์สองเครื่องพร้อมกัน เมื่อเซิร์ฟเวอร์หลักตัวหนึ่ง (หรือที่เรียกว่าเซิร์ฟเวอร์หลัก) ไม่สามารถรับมือได้อีกต่อไป เซิร์ฟเวอร์ก็จะเปลี่ยนไปใช้เซิร์ฟเวอร์สำรอง
ทั้งหมด คำขออัพเดตฐานข้อมูลจะไปที่เซิร์ฟเวอร์หลักเสมอ. หลังจากอัพเดตเฮดเซิร์ฟเวอร์แล้ว ระบบจะใส่ข้อมูลเกี่ยวกับสิ่งนี้ไว้ แยกไฟล์โดยที่เซิร์ฟเวอร์ทาสรับข้อมูลทั้งหมด แต่การดำเนินการสุ่มตัวอย่างซึ่งโดยปกติจะเป็นส่วนใหญ่และช้าที่สุด สามารถถ่ายโอนไปยังเซิร์ฟเวอร์ทาสได้แล้ว เนื่องจากข้อมูลทั้งสองจะเหมือนกัน
ทีนี้มาคิดออกกัน วิธีกำหนดค่าการจำลองแบบใน MySQL:
- ติดตั้งให้มากที่สุด MySQL เวอร์ชันล่าสุดไปยังเซิร์ฟเวอร์ทั้งหมด
- สร้างผู้ใช้ที่มีสิทธิ์บนเซิร์ฟเวอร์หลัก แทนที่ทาส. สำหรับที่อยู่ที่สามารถเชื่อมต่อได้ ให้ระบุ " ทั้งหมด".
- หยุดเซิร์ฟเวอร์ทั้งหมด
- ในการตั้งค่า MySQL(ในไฟล์ my.cnf) ในบทที่
เพิ่มบรรทัดต่อไปนี้: log-bin
server-id=1 โปรดทราบว่า รหัสเซิร์ฟเวอร์จะต้องแตกต่างกันบนเซิร์ฟเวอร์ทั้งหมด อันที่จริงนี่คือสิ่งที่ทำให้เซิร์ฟเวอร์หนึ่งแตกต่างจากเซิร์ฟเวอร์อื่น - บนเซิร์ฟเวอร์ทาส ให้เพิ่มการตั้งค่า 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 - ย้ายฐานทั้งหมดจากเซิร์ฟเวอร์หลักไปจนถึงทาส
- วิ่งหัวหน้าเซิร์ฟเวอร์ แล้วก็ทาสทั้งหมด
