SQL Academy · บทเรียน

แบบจำลองสำหรับอ่านและการกำหนดเส้นทางการเชื่อมต่อ

กำหนดเส้นทางการรับส่งข้อมูลแบบอ่านอย่างเดียวไปยังแบบจำลองด้วย PgBouncer หรือไดรเวอร์อัจฉริยะ และยอมรับข้อแลกเปลี่ยนด้านความล้าสมัยของข้อมูล

แบบจำลองสำหรับอ่านและการกำหนดเส้นทางการเชื่อมต่อ เป็นบทเรียน SQL Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน SQL Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส SQL Academy มีบทเรียนทั้งหมด 4 บทเรียน

เหตุใดจึงใช้แบบจำลองสำหรับอ่าน

งานที่เน้นการอ่านสามารถแบ่งคำสั่ง SELECT ไปยังแบบจำลองได้:

เซิร์ฟเวอร์หลักจัดการการเขียน
แบบจำลองจัดการการอ่านส่วนใหญ่
เพิ่มขนาดการอ่านในแนวนอนได้โดยไม่ต้องแบ่งชาร์ด

ข้อควรระวังเรื่องความสอดคล้องในที่สุด

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

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

กลยุทธ์การกำหนดเส้นทาง

การกำหนดเส้นทางระดับแอปพลิเคชัน — โค้ดแอปเลือกว่าจะใช้เซิร์ฟเวอร์หลักหรือแบบจำลอง
การกำหนดเส้นทางระดับไดรเวอร์ — JDBC, pgjdbc หรือ pgxpool จัดการกลุ่มการเชื่อมต่อโดยรู้จักเซิร์ฟเวอร์หลักและแบบจำลอง
การกำหนดเส้นทางระดับพร็อกซี — pgpool, pgbouncer หรือ HAProxy ตรวจจับการอ่านและการเขียน

การกำหนดเส้นทางของแอปพลิเคชัน

พูลการเชื่อมต่อสองชุด ชุดละหนึ่งบทบาท:

const primary = new Pool({ host: 'primary', ... });
const replica = new Pool({ host: 'replica', ... });

// reads go to replica:
await replica.query('SELECT ...');

// writes (and read-your-writes) go to primary:
await primary.query('INSERT ...');

PgPool-II

พร็อกซีที่วิเคราะห์ SQL และกำหนดเส้นทาง SELECT ไปยัง replica และการเขียนไปยัง primary รองรับการปรับสมดุลโหลดและพูลการเชื่อมต่อ:

# pgpool.conf
backend_hostname0 = 'primary'
backend_hostname1 = 'replica1'
load_balance_mode = on

HAProxy พร้อมการตรวจสอบด้วย pg_isready

HAProxy ไม่เข้าใจ SQL แต่สามารถกำหนดเส้นทางตามพอร์ตได้ โดยมีส่วนหน้าชุดหนึ่งสำหรับการเขียน (ไปยัง primary) และอีกชุดสำหรับการอ่าน (ไปยัง replica พร้อมการตรวจสอบสถานะ):

frontend writes
  bind *:5432
  default_backend primary_pool

frontend reads
  bind *:5433
  default_backend replicas_pool
  balance roundrobin

ปลายทาง AWS RDS

RDS มีปลายทางสำหรับผู้เขียนเพียงจุดเดียว และปลายทางสำหรับผู้อ่านที่ปรับสมดุลโหลดระหว่าง replica ทั้งหมด ซึ่งเป็นวิธีที่ง่ายที่สุดบนคลาวด์

ข้อควรพิจารณาเกี่ยวกับความล่าช้าของการจำลองข้อมูล

ติดตามความล่าช้า และหลีกเลี่ยงการกำหนดเส้นทางไปยัง replica ที่ตามหลังมากเกินไป:

-- On primary:
SELECT client_addr, replay_lag FROM pg_stat_replication;

-- HAProxy / pgpool can use a custom health check that fails if replay_lag > threshold.

รูปแบบเซสชันแบบยึดติด

สำหรับกรณี "อ่านข้อมูลที่เพิ่งเขียนด้วยตนเอง": ให้ผูกเซสชันของผู้ใช้ไว้กับ primary เป็นเวลา N วินาทีหลังการเขียน หรือประทับ LSN ของการเขียน แล้วรอให้ replica จำลองข้อมูลตามจนเสร็จก่อนจึงให้บริการ

การรอตาม LSN

หลังการเขียน ให้บันทึก LSN ก่อนอ่านจาก replica ให้รอจนกว่า replica จะจำลองข้อมูลมาถึง LSN นั้น:

-- After write on primary:
SELECT pg_current_wal_lsn();        -- save this

-- Before read on replica:
SELECT pg_last_wal_replay_lsn() >= $saved_lsn;
-- spin or wait until true

การใช้แคชเป็น Replica

บางครั้ง Redis / Memcache ทำหน้าที่เป็น "replica" เพื่อขยายการอ่าน ซึ่งเร็วกว่าอินสแตนซ์ PostgreSQL อีกชุดมากสำหรับคีย์ที่มีการใช้งานสูง

เมื่อใดที่ไม่ควรใช้ Replica

หากภาระงานของคุณเน้นการเขียน replica จะเพิ่มต้นทุนเป็นหลักโดยไม่ได้เพิ่มความเร็วมากนัก หากการอ่านบน primary เร็วอยู่แล้ว คุณอาจไม่จำเป็นต้องใช้ replica

การกู้คืนจากภัยพิบัติกับการขยายการอ่าน

การทำงานแบบสลับระบบของ replica สำหรับ HA เป็นคนละประเด็นกับ replica สำหรับขยายการอ่าน โดยบ่อยครั้งคุณจะมีทั้งสองแบบ

สรุป

Read replica ช่วยขยายการอ่าน แต่มีความล่าช้าติดมาด้วย

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

ตรวจสอบความเข้าใจอย่างรวดเร็ว

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

คำถามที่พบบ่อย

บทเรียน “แบบจำลองสำหรับอ่านและการกำหนดเส้นทางการเชื่อมต่อ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “แบบจำลองสำหรับอ่านและการกำหนดเส้นทางการเชื่อมต่อ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส SQL Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส SQL Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “แบบจำลองสำหรับอ่านและการกำหนดเส้นทางการเชื่อมต่อ”

กำหนดเส้นทางการรับส่งข้อมูลแบบอ่านอย่างเดียวไปยังแบบจำลองด้วย PgBouncer หรือไดรเวอร์อัจฉริยะ และยอมรับข้อแลกเปลี่ยนด้านความล้าสมัยของข้อมูล คุณปฏิบัติ SQL Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน SQL Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน SQL Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “แบบจำลองสำหรับอ่านและการกำหนดเส้นทางการเชื่อมต่อ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน SQL Academy นี้ได้ไหม

ได้ บทเรียน SQL Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

การจำลองแบบสตรีมมิงและ WAL
การจำลองแบบเชิงตรรกะสำหรับการแบ่งข้อมูล
การสลับระบบสำรองและการเลือกผู้นำ (Patroni, Stolon)
แบบจำลองสำหรับอ่านและการกำหนดเส้นทางการเชื่อมต่อ

← กลับไปที่ SQL Academy