การสำรองข้อมูลอัตโนมัติด้วย rsync บน Linux

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

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

rsync คืออะไร และทำไมจึงถูกใช้มากในการสำรองข้อมูล?

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

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

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

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

ติดตั้งและทดสอบ rsync บนระบบปฏิบัติการต่างๆ

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

บนระบบที่ใช้ Debian หรือ Ubuntu คุณสามารถทำสิ่งง่ายๆ ได้ดังนี้:

rsync --version
sudo apt update
sudo apt install rsync

ในระบบปฏิบัติการอย่าง RHEL, CentOS, Rocky Linux หรือระบบอื่นๆ ที่พัฒนาต่อยอดจาก RHEL ขั้นตอนจะคล้ายกันมาก โดยจะเปลี่ยนเฉพาะตัวจัดการแพ็กเกจ แต่ยังคงหลักการเดียวกันคือ... ตรวจสอบให้แน่ใจว่า rsync พร้อมใช้งานและเป็นเวอร์ชันล่าสุด ในทั้งสองอย่างสุดขั้ว

rsync --version
sudo dnf install rsync # En sistemas modernos
sudo yum install rsync # En sistemas más antiguos

ตัวเลือกพื้นฐานของ rsync ที่คุณจะใช้บ่อยๆ

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

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

ไวยากรณ์ทั่วไป:

rsync ORIGEN DESTINO

ความแตกต่างที่สำคัญอยู่ที่วิธีการจัดการกับไดเร็กทอรีต้นทาง:

# Copia el directorio como tal dentro del destino
rsync -av /source/dir /backup/

# คัดลอกเฉพาะเนื้อหาของไดเร็กทอรีไปยังปลายทาง
rsync -av /source/dir/ /สำรอง/

ตัวเลือกการสำรองข้อมูลที่ใช้กันทั่วไปบางส่วนนั้นมีประโยชน์อย่างยิ่งเพราะ พวกเขาได้รวบรวมหลายสิ่งหลายอย่างไว้ในข้อความสั้นๆ:

• -aโหมดไฟล์ เทียบเท่ากับ -rlptgoD (แบบเรียกซ้ำ รักษาลิงก์สัญลักษณ์ สิทธิ์การเข้าถึง เวลาประทับ กลุ่ม เจ้าของ และไฟล์พิเศษ)
• -vโหมด "ละเอียด" จะแสดงให้เห็นว่าโปรแกรมกำลังทำอะไรและกำลังเข้าถึงไฟล์ใดบ้าง
• -z: บีบอัดข้อมูลระหว่างการถ่ายโอน เหมาะอย่างยิ่งสำหรับการคัดลอกระยะไกลผ่านทางอินเทอร์เน็ต
• -h: ทำให้ขนาดดู "สวยงาม" (MB, GB…) เหมาะสำหรับมนุษย์
• -P: รวมความคืบหน้าและไฟล์บางส่วนเข้าด้วยกัน เพื่อให้เห็นภาพรวมและสามารถดำเนินการต่อได้
• -ลบ: ลบไฟล์ที่ไม่มีอยู่แล้วในแหล่งที่มา ณ ปลายทาง เหลือไว้เพียงสำเนาที่เหมือนกันทุกประการ
• -n / –dry-run: จำลองการทำงานโดยไม่ต้องแตะต้องอะไรเลย เหมาะอย่างยิ่งสำหรับการป้องกันไม่ให้เกิดความผิดพลาด
• –ยกเว้น / –ยกเว้นจาก: ช่วยให้คุณสามารถยกเว้นรูปแบบหรือรายการเส้นทางทั้งหมดที่คุณไม่ต้องการคัดลอกได้
• –ลิงก์ปลายทาง: สร้างฮาร์ดลิงก์กับสำเนาเก่า ซึ่งเป็นพื้นฐานของการสำรองข้อมูลแบบเพิ่มทีละส่วนคล้ายกับ Time Machine

สำเนาในเครื่องและตัวอย่างแรกแบบแมนนวล

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

หากคุณต้องการคัดลอกไดเร็กทอรีโฮมของคุณไปยังที่อื่น ดิสก์สำรองข้อมูลภายในเครื่องคำสั่งแบบย่อที่สุดจะมีลักษณะดังนี้:

rsync -av /home/usuario/ /mnt/disco_backup/usuario/

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

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

rsync -av /media/fotos/ /backup/fotos/

เมื่อพูดถึงข้อมูลระบบที่ละเอียดอ่อน เช่น /etc หรือ /var/wwwเป็นเรื่องปกติที่จะต้องการสำเนาที่เหมือนต้นฉบับทุกประการ โดยลบสิ่งที่หายไปจากต้นฉบับออกจากสำเนาสำรอง นั่นคือเหตุผลที่ต้องใช้ตัวเลือกการลบ

rsync -av --delete /var/www/ /backup/www/

การสำรองข้อมูลระยะไกลที่ปลอดภัยด้วย SSH

จุดเด่นที่แท้จริงของ rsync คือเมื่อคุณนำไปใช้ร่วมกับ... SSH สำหรับส่งสำเนาออกจากเซิร์ฟเวอร์ด้วยวิธีนี้ คุณสามารถจัดเก็บข้อมูลของคุณไว้ในโหนดอื่นในเครือข่ายของคุณ เช่น NAS หรือ VPS บนอินเทอร์เน็ต วิธีนี้คุณจะไม่ต้องพึ่งพาอุปกรณ์เพียงเครื่องเดียว และคุณยังปฏิบัติตามส่วนหนึ่งของกฎ 3-2-1 ที่มีชื่อเสียง (อย่างน้อยต้องมีสำเนาสำรองไว้ภายนอกสถานที่หนึ่งชุด)

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

# Empujar datos locales a un servidor remoto de backup
rsync -avz /etc/ backup@servidor-remoto:/backups/etc/

# การนำข้อมูลจากเซิร์ฟเวอร์ระยะไกลมายังเครื่องสำรองข้อมูลของคุณ
rsync -avz backup@remote-server:/var/www/ /backups/www/

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

rsync -avz \
-e "ssh -p 2222 -c -o Compression=no" \
/origen/ backup@servidor-remoto:/destino/

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

rsync -avz --bwlimit=5000 /datos/ backup@servidor-remoto:/backups/datos/

การสำรองข้อมูลแบบเต็มรูปแบบ แบบส่วนต่าง และแบบเพิ่มทีละน้อยด้วย rsync

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

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

# Copia completa de un árbol de directorios
rsync -a /ruta/origen/ /ruta/destino/

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

# Copia diferencial, manteniendo el destino idéntico al origen
rsync -a --delete /ruta/origen/ /ruta/destino/

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

# Copia incremental apoyada en una copia previa
rsync -a --link-dest=/ruta/a/copiaprevia \
/ruta/origen/ /ruta/destino-incremental/

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

การสำรองข้อมูลแบบ Time Machine พร้อมสแนปช็อตและฮาร์ดลิงก์

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

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

คำสั่งทั่วไปในรูปแบบนั้นอาจมีลักษณะดังนี้:

rsync -avPh --delete \
--link-dest="$TARGETDIR/current" \
"$SOURCEDIR/$USER/" \
"$TARGETDIR/$USER-$TIMESTAMP"

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

การทำงานแบบอัตโนมัติเกิดขึ้นเองตามธรรมชาติ: คุณเพียงแค่บันทึกสคริปต์ลงในที่ใดที่หนึ่ง เช่น... /usr/local/bin/rsync-time-machine และตั้งเวลาให้รันทุกวันด้วย cron ในเวลาที่เหมาะสมที่สุดสำหรับคุณ

0 5 * * * bash /usr/local/bin/rsync-time-machine

ตั้งค่าการสำรองข้อมูลอัตโนมัติด้วย cron เป็นประจำทุกวัน

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

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

ตัวอย่างสคริปต์ง่ายๆ สำหรับการคัดลอกไฟล์ในเครื่องอาจเป็นดังนี้:

#!/bin/bash
SOURCE_DIR="/home"
BACKUP_DIR="/backup/home"
LOG_FILE="/var/log/backup/rsync-local.log"
DATE=$(date +"%Y-%m-%d %H:%M:%S")

mkdir -p «$BACKUP_DIR» «$(dirname «$LOG_FILE»)»
echo "เริ่มการสำรองข้อมูลในเครื่อง" >> "$LOG_FILE"

rsync -av –delete
–exclude='*.tmp' \
–exclude='.cache' \
–exclude='Downloads/*' \
«$SOURCE_DIR/» «$BACKUP_DIR/» >> «$LOG_FILE» 2>&1

ถ้า ; แล้ว
echo » การสำรองข้อมูลเสร็จสมบูรณ์แล้ว» >> «$LOG_FILE»
อื่น
echo » การสำรองข้อมูลที่มีข้อผิดพลาด» >> «$LOG_FILE»
fi

เมื่อคุณใส่สคริปต์เข้าไปแล้ว ตัวอย่างเช่น /usr/local/bin/rsync-local-backup.sh และเมื่อกำหนดให้เป็นไฟล์ที่สามารถเรียกใช้งานได้ คุณก็สามารถเพิ่มลงใน cron เพื่อให้มันทำงานในเวลาที่กำหนดได้

sudo chmod +x /usr/local/bin/rsync-local-backup.sh
sudo crontab -e

ภายใน crontab คุณสามารถใส่ข้อความประมาณนี้ได้:

0 2 * * * /usr/local/bin/rsync-local-backup.sh

ตัวจับเวลา systemd: ทางเลือกที่ทันสมัยกว่า cron

ในระบบสมัยใหม่นั้น มักจะคุ้มค่าที่จะทำเช่นนั้น ใช้ตัวจับเวลา systemd แทน cronโดยเฉพาะอย่างยิ่งหากคุณต้องการผสานรวมบริการต่างๆ ได้ดียิ่งขึ้น จัดการการพึ่งพาเครือข่าย หรือมีบันทึกส่วนกลางใน journalctl

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


Description=Rsync Backup Service
After=network-online.target
Wants=network-online.target

ประเภท = oneshot
ExecStart=/usr/local/bin/rsync-remote-backup.sh
ผู้ใช้=รูท
StandardOutput=journal
StandardError=journal
เวลาหมดเวลา = 7200 วินาที

WantedBy = multi-user.target

และตัวจับเวลาที่เกี่ยวข้องจะถูกกำหนดดังต่อไปนี้ สำหรับ สำรองข้อมูลทุกวันเวลาตี 2 โดยใส่ความสุ่มเข้าไปบ้างเพื่อไม่ให้ทุกอย่างดูรกไปหมดในคราวเดียว:


Description=Daily Rsync Backup Timer
Requires=rsync-backup.service

OnCalendar=*-*-* 02:00:00
คงที่=จริง
RandomizedDelaySec=10min

WantedBy=timers.target

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

sudo systemctl daemon-reload
sudo systemctl enable --now rsync-backup.timer
systemctl list-timers
journalctl -u rsync-backup.service

จัดทำระบบสำรองข้อมูลแบบหมุนเวียน: รายวัน รายสัปดาห์ และรายเดือน

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

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

#!/bin/bash
SOURCE_DIR="/var/www"
BACKUP_ROOT="/backup/www"
CURRENT="$BACKUP_ROOT/current"
DAILY="$BACKUP_ROOT/daily"
WEEKLY="$BACKUP_ROOT/weekly"
MONTHLY="$BACKUP_ROOT/monthly"
DATE=$(date +%Y%m%d)
DOW=$(date +%u)
DOM=$(date +%d)

mkdir -p «$CURRENT» «$DAILY» «$WEEKLY» «$MONTHLY»

rsync -av –delete –link-dest=»$CURRENT» \
«$SOURCE_DIR/» «$CURRENT/»

&& cp -al «$CURRENT» «$DAILY/$DATE»
&& cp -al «$CURRENT» «$WEEKLY/$DATE»
&& cp -al «$CURRENT» «$MONTHLY/$DATE»

find «$DAILY» -maxdepth 1 -type d -mtime +7 -exec rm -rf {} \;
find «$WEEKLY» -maxdepth 1 -type d -mtime +28 -exec rm -rf {} \;
find «$MONTHLY» -maxdepth 1 -type d -mtime +365 -exec rm -rf {} \;

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

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

ตรวจสอบ ยืนยัน และดูว่าข้อมูลสำรองของคุณมีประโยชน์หรือไม่

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

กลยุทธ์ง่ายๆ คือการสร้างไฟล์บันทึกขนาดเล็กไว้ในโฟลเดอร์ปลายทางทุกครั้งที่การสำรองข้อมูลเสร็จสมบูรณ์ เช่น ไฟล์ .last-backup-success ที่ระบุวันที่ จากนั้น สคริปต์ภายนอก หรือแม้แต่การตรวจสอบโดย Nagios/Icinga ก็สามารถแจ้งเตือนคุณได้หากไฟล์นั้นเก่าเกินไป

MARKER="/backup/www/.last-backup-success"
if ; then
echo "Marcador de backup no encontrado"
exit 1
fi

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

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

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