Computer >> คอมพิวเตอร์ >  >> การเขียนโปรแกรม >> ฐานข้อมูล

การจำลองแบบใน PostgresSQL

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

แนะนำตัว

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

รายละเอียดการจำลอง

ถึงเวลาทำความเข้าใจโหมดการจำลอง โมเดล และประเภทของการจำลองแบบใน PostgreSQL และเรียนรู้เกี่ยวกับการบันทึกการเขียนล่วงหน้า

โหมดอะซิงโครนัสและซิงโครนัส

ไดอะแกรมต่อไปนี้แสดงโหมดของการจำลองแบบ PostgreSQL:

การจำลองแบบใน PostgresSQL

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

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

แบบจำลองการจำลองแบบเดี่ยวและแบบหลายแหล่ง

ด้วย แหล่งเดียว การจำลองแบบ คุณมีเซิร์ฟเวอร์ต้นทางเพียงแห่งเดียวและเซิร์ฟเวอร์จำลองอย่างน้อยหนึ่งเซิร์ฟเวอร์ ต้นทางส่งธุรกรรมการจำลองแบบไปยังแบบจำลองทั้งหมด

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

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

ประเภทของการจำลอง

การจำลองแบบมีสามประเภท:

  • การจำลองการสตรีม :PostgreSQL ทำให้การจำลองประเภทนี้พร้อมใช้งานในเวอร์ชัน 9 และใหม่กว่า แบบจำลองพร้อมใช้งานสำหรับคิวรีแบบใช้เลือกคำสั่งที่ทำงานอย่างเดียว ข้อกำหนดหลักสำหรับประเภทนี้คือแหล่งที่มาและฐานข้อมูลจำลองต้องเป็นเวอร์ชันหลักเดียวกัน
  • การจำลองแบบเรียงซ้อน :เปิดตัวใน PostgreSQL 9.2 ประเภทการจำลองแบบของเขาช่วยให้คุณทำซ้ำจากเซิร์ฟเวอร์สแตนด์บายแทนการโดยตรงจากเซิร์ฟเวอร์ต้นทาง ซึ่งสามารถลดภาระงานบนเซิร์ฟเวอร์ต้นทางได้
  • การจำลองแบบลอจิคัล :คุณสามารถใช้ประเภทนี้เพื่อจำลองชุดข้อมูลหรือออบเจ็กต์ฐานข้อมูลที่เลือก หรือเพื่อทำซ้ำระหว่าง PostgreSQL เวอร์ชันหลักต่างๆ การจำลองแบบเชิงตรรกะ คุณสามารถใช้เซิร์ฟเวอร์สแตนด์บายสำหรับการเขียนได้ แต่มีข้อจำกัดบางประการ ไม่สามารถทำซ้ำ Truncate, ออบเจ็กต์ขนาดใหญ่ เช่น (lob, blob, clob ),sequences, schema และ DDL

การบันทึกแบบเขียนล่วงหน้า

ก่อนที่คุณจะเริ่มใช้การจำลองแบบสตรีมมิง คุณควรเข้าใจการบันทึกล่วงหน้า (WAL) และวิธีการทำงาน

ใน PostgreSQL อันดับแรก ระบบจะบันทึกการเปลี่ยนแปลงใดๆ ที่ทำกับฐานข้อมูลในไฟล์บันทึกก่อนที่จะบันทึกลงในไฟล์ข้อมูล และการเปลี่ยนแปลงเหล่านี้เรียกว่าระเบียน WAL ทุกระเบียน WAL มีหมายเลขที่ไม่ซ้ำกันซึ่งเรียกว่าหมายเลขลำดับการบันทึก (LSN)

ด้วยการจำลองแบบสตรีมมิ่งใน PostgreSQL เซิร์ฟเวอร์ฐานข้อมูลแบบจำลองจะใช้ไฟล์ WAL เพื่อจำลองการเปลี่ยนแปลงบนเซิร์ฟเวอร์ฐานข้อมูลต้นทาง

กระบวนการบังคับสามขั้นตอนมีบทบาทสำคัญในการจำลองแบบสตรีมมิงบนฐานข้อมูล PostgreSQL:

  • ผู้ส่ง WAL
  • เครื่องรับ WAL
  • การเริ่มต้น

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

  1. กระบวนการรับ WAL จะส่ง LSN จนกว่าแบบจำลองจะเล่นซ้ำข้อมูล WAL ไปยังต้นแบบ
  2. กระบวนการผู้ส่ง WAL บนต้นทางจะส่งข้อมูล WAL ไปยังแบบจำลองจนกว่าจะถึง LSN ล่าสุดที่ส่งโดยเครื่องรับ WAL
  3. ถัดไป เครื่องรับ WAL จะเขียนข้อมูล WAL ที่ส่งโดยผู้ส่ง WAL ไปยังเซ็กเมนต์ WAL
  4. กระบวนการเริ่มต้นบนแบบจำลองจะเล่นซ้ำข้อมูลที่เขียนไปยังเซ็กเมนต์ WAL
  5. สุดท้าย การจำลองแบบสตรีมมิ่งเริ่มต้นขึ้น

กรณีทดสอบ

ต่อไปนี้คือขั้นตอนในการตั้งค่าการจำลองการสตรีมใน PostgreSQL ระหว่างซอร์สและตัวจำลอง:

ขั้นที่หนึ่ง

อันดับแรก เราต้องตรวจสอบให้แน่ใจว่าเซิร์ฟเวอร์ต้นทางและเซิร์ฟเวอร์จำลองมีการกำหนดค่า SSHauthentication แบบไม่มีรหัสผ่าน ถ้าไม่ เราต้องกำหนดค่าโดยใช้ ssh-keygen .

หากต้องการเรียนรู้เกี่ยวกับการกำหนดค่า SSH แบบไม่ใช้รหัสผ่าน โปรดดูที่https://linuxize.com/post/how-to-setup-passwordless-ssh-login/

Source node 192.168.24.28 
Replica node 192.168.24.29
Username `postgres` on both source and replica.

ขั้นตอนที่สอง

เรียกใช้คำสั่งต่อไปนี้บนเซิร์ฟเวอร์ทั้งสองเพื่อหยุดไฟร์วอลล์:

$ sudo systemctl stop firewalld
$ sudo systemctl disable firewalld

ขั้นตอนที่สาม

  1. บนเซิร์ฟเวอร์ต้นทาง ไปที่ไดเร็กทอรีข้อมูล:

     cd /var/lib/pgsql/11/data
    
  2. แก้ไข postgresql.conf ไฟล์และทำการเปลี่ยนแปลงดังต่อไปนี้:

     archive_mode = on
     archive_command = ‘cp %p /var/lib/pgsql/archive/%f’
     max_wall_senders = 5
     wal_keep_segment =32
     wal_level = replica
     listen_addresses = ‘*’
    
  3. เพิ่มรายการที่อยู่ IP ของเซิร์ฟเวอร์จำลองใน pg_hba.conf :

     host    postgres         postgres         (ip_address)192.168.24.29/32 trust
     host    replication      postgres         (ip_address)192.168.24.29/32 trust
    
  4. สำหรับทุกการเปลี่ยนแปลงใน pg_hba.conf , โหลดบริการใหม่:

     $ /usr/local/pgsql_11/bin/pg_ctl -D /var/lib/pgsql/11/ reload
    
  5. สร้าง /var/lib/pgsql/archive/ ไดเรกทอรีเก็บถาวรหากไม่มีอยู่

  6. รีสตาร์ทเซิร์ฟเวอร์เพื่อแสดงการเปลี่ยนแปลง

ขั้นตอนที่สี่

บนเซิร์ฟเวอร์จำลอง:

  1. ไปที่ไดเร็กทอรีข้อมูลและหยุดบริการ:

     $ /usr/pgsql-11/bin/pg_ctl -D /var/lib/pgsql/11/data/ stop
    
  2. ลบทุกอย่างออกจากไดเร็กทอรีข้อมูลบนเรพลิกา และลองเชื่อมต่อกับซอร์สโดยใช้คำสั่งต่อไปนี้:

     $ /usr/pgsql-11/bin/psql -h 192.168.24.28
    
  3. หากใช้งานได้ ให้เริ่มการสำรองข้อมูลพื้นฐานจากเรพลิกา:

     $ cd /var/lib/pgsql/11/data
     $ /usr/pgsql-11/bin/pg_basebackup -D /var/lib/pgsql/11/data/ -X fetch -h 192.168.24.28 -R -P
    

คำสั่งเหล่านี้จะคัดลอกข้อมูลทั้งหมดจากไดเร็กทอรีข้อมูลของฐานข้อมูลต้นทางไปยังไดเร็กทอรีข้อมูลเรพพลิกาและสร้าง recovery.conf ไฟล์.

ขั้นตอนที่ 5

หลังจากการสำรองข้อมูลพื้นฐานเสร็จสิ้น คุณจะต้องตรวจสอบ recovery.conf ไฟล์. เซิร์ฟเวอร์ใดก็ได้ที่มี recovery.conf ไฟล์ในไดเร็กทอรีข้อมูลเป็นเซิร์ฟเวอร์จำลองและมีข้อมูลของเซิร์ฟเวอร์ต้นทาง ทำการแก้ไขดังต่อไปนี้:

Standby_mode = ‘on’
Primary_conninfo = ‘user=postgres host=192.168.24.28 port=5432’

ไฟล์ควรปรากฏดังนี้:

$ Vi recovery.conf
Standby_mode = ‘on’
Primary_conninfo = ‘user=postgres passfile=’’/home/postgres/.pgpass’’ host=192.168.24.28 port=5432 sslmode=disable sslcompression=0 target_session_attrs=any’

ขั้นตอนที่หก

ตอนนี้เริ่มเซิร์ฟเวอร์และตรวจสอบการเปลี่ยนแปลง:

  1. เข้าสู่ระบบแหล่งที่มา:

     /usr/local/pgsql_11/bin/psql
     Postgres=# 
    
     Postgres=# Select * from pg_stat_replication;
    
     -[ RECORD 1 ]----+------------------------------
     pid              | 1934
     usesysid         | 26712
     usename          | postgres
     application_name | walreceiver
     client_addr      | 192.168.24.29
     client_hostname  |
     client_port      | 52143
     backend_start    | 2020-11-07 11:30:31.035614-05
     backend_xmin     |
     state            | streaming
     sent_lsn         | 0/50000E34
     write_lsn        | 0/50000E34
     flush_lsn        | 0/50000E34
     replay_lsn       | 0/50000E34
     write_lag        |
     flush_lag        |
     replay_lag       |
     sync_priority    | 0
     sync_state       | async
    
  2. เข้าสู่ระบบการจำลอง:

     /usr/local/pgsql_11/bin/psql
     Postgres=# 
    
     Postgres=# Select * from pg_is_in_recovery();
     Pg_is_in_recovery
     ----------------------------------
     t
    
  3. ตรวจสอบด้วยคำสั่งระดับ OS จากต้นทาง:

     $ ps -ef|grep sender 
    
     postgres  1934 
     1718  0 11:31 ?        00:00:00 postgres: wal sender process replicator 192.168.24.29(52143) streaming 0/50000E34
    
  4. ตรวจสอบด้วยคำสั่งระดับ OS จากเรพลิกา:

     $ ps -ef|grep receiver
    
     postgres  1358 
     1748  0 11:31 ?        00:00:04 postgres: wal receiver process   streaming 0/50000E34
    

    ธุรกรรมผู้ส่งและผู้รับควรเหมือนกัน และการจำลองจะเป็นโหมดอ่านอย่างเดียวเสมอ

  5. (ไม่บังคับ) โดยค่าเริ่มต้น การจำลองแบบอยู่ในโหมดอะซิงโครนัส หากต้องการเปลี่ยนเป็น synchronousreplication ให้ไปที่เซิร์ฟเวอร์ต้นทางและทำการเปลี่ยนแปลงต่อไปนี้เป็น postgresql.conf :

     synchronous_standby_names=’*’ in 
    

    จากนั้นเริ่มบริการใหม่:

     $ /usr/local/pgsql-11/bin/pg_ctl -D /var/lib/pgsql/11/ restart
    

บทสรุป

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

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

เรียนรู้เพิ่มเติมเกี่ยวกับบริการข้อมูลของเรา

ใช้แท็บคำติชมเพื่อแสดงความคิดเห็นหรือถามคำถาม คุณสามารถเริ่มการสนทนากับเราได้