LVM आणि Matryoshka मध्ये काय साम्य आहे?

Доброго времени суток.
md RAID + LVM वापरून KVM साठी डेटा स्टोरेज सिस्टीम तयार करण्याचा माझा व्यावहारिक अनुभव मी समुदायासोबत शेअर करू इच्छितो.

कार्यक्रमात हे समाविष्ट असेल:

• NVMe SSD कडून md RAID 1 तयार करणे.
• SATA SSD आणि नियमित ड्राइव्हवरून md RAID 6 एकत्र करणे.
• SSD RAID 1/6 वर TRIM/DISCARD ऑपरेशनची वैशिष्ट्ये.
• डिस्कच्या सामान्य संचावर बूट करण्यायोग्य md RAID 1/6 अॅरे तयार करणे.
• BIOS मध्ये NVMe समर्थन नसताना NVMe RAID 1 वर प्रणाली स्थापित करणे.
• LVM कॅशे आणि LVM पातळ वापरणे.
• BTRFS स्नॅपशॉट वापरणे आणि बॅकअपसाठी पाठवा/प्राप्त करा.
• BTRFS शैली बॅकअपसाठी LVM पातळ स्नॅपशॉट्स आणि thin_delta वापरणे.

आपल्याला स्वारस्य असल्यास, कृपया मांजर पहा.

विधान

या लेखातील साहित्य/उदाहरणे/कोड/टिपा/डेटा वापरणे किंवा न वापरणे याच्या परिणामांसाठी लेखक कोणतीही जबाबदारी घेत नाही. ही सामग्री कोणत्याही प्रकारे वाचून किंवा वापरून, आपण या क्रियांच्या सर्व परिणामांची जबाबदारी स्वीकारता. संभाव्य परिणामांमध्ये हे समाविष्ट आहे:

• कुरकुरीत-तळलेले NVMe SSDs.
• रेकॉर्डिंग संसाधन पूर्णपणे वापरले आणि SSD ड्राइव्हचे अपयश.
• बॅकअप प्रतींसह सर्व ड्राइव्हवरील सर्व डेटाचे संपूर्ण नुकसान.
• सदोष संगणक हार्डवेअर.
• वेळ, नसा आणि पैसा वाया घालवला.
• वर सूचीबद्ध नसलेले इतर कोणतेही परिणाम.

लोखंड

उपलब्ध होते:

मदरबोर्ड सुमारे 2013 पासून Z87 चिपसेटसह, Intel Core i7 / Haswell सह पूर्ण.

• प्रोसेसर 4 कोर, 8 थ्रेड्स
• 32 GB DDR3 रॅम
• 1 x 16 किंवा 2 x 8 PCIe 3.0
• 1 x 4 + 1 x 1 PCIe 2.0
• 6 x 6 GBps SATA 3 कनेक्टर

SAS अडॅप्टर LSI SAS9211-8I IT/HBA मोडवर फ्लॅश झाला. RAID-सक्षम फर्मवेअर हे जाणूनबुजून HBA फर्मवेअरने बदलले गेले आहे:

1. तुम्ही हे अॅडॉप्टर कधीही फेकून देऊ शकता आणि तुमच्या समोर आलेल्या इतर कोणत्याही अॅडॉप्टरने ते बदलू शकता.
2. TRIM/Discard सामान्यपणे डिस्कवर काम करते, कारण... RAID फर्मवेअरमध्ये या आज्ञा अजिबात समर्थित नाहीत, आणि एचबीए, सर्वसाधारणपणे, बसवर कोणत्या आज्ञा प्रसारित केल्या जातात याची काळजी घेत नाही.

हार्ड ड्राइव्हस् - HGST Travelstar 8K7 चे 1000 तुकडे 1 TB क्षमतेच्या 2.5 फॉर्म फॅक्टरमध्ये, लॅपटॉपसाठी. हे ड्राइव्ह पूर्वी RAID 6 अॅरेमध्ये होते. नवीन प्रणालीमध्ये त्यांचाही उपयोग होईल. स्थानिक बॅकअप संचयित करण्यासाठी.

अतिरिक्त जोडले:

6 तुकडे SATA SSD मॉडेल Samsung 860 QVO 2TB. या SSD ला मोठ्या प्रमाणाची आवश्यकता होती, SLC कॅशेची उपस्थिती, विश्वासार्हता आणि कमी किंमत हवी होती. टाकून द्या/शून्य साठी समर्थन आवश्यक होते, जे dmesg मधील ओळीद्वारे तपासले जाते:

kernel: ata1.00: Enabling discard_zeroes_data

NVMe SSD मॉडेल सॅमसंग SSD 2 EVO 970GB चे 500 तुकडे.

या SSD साठी, यादृच्छिक वाचन/लेखनाचा वेग आणि तुमच्या गरजांसाठी संसाधन क्षमता महत्त्वाची आहे. त्यांच्यासाठी रेडिएटर. अपरिहार्यपणे. एकदम. अन्यथा, पहिल्या RAID सिंक्रोनाइझेशन दरम्यान ते कुरकुरीत होईपर्यंत तळा.

PCIe 8 2x स्लॉटमध्ये 2 x NVMe SSD साठी StarTech PEX2M3.0E8 अडॅप्टर स्थापित. हे, पुन्हा, फक्त एक HBA आहे, परंतु NVMe साठी. हे स्वस्त अडॅप्टरपेक्षा वेगळे आहे कारण अंगभूत PCIe स्विचच्या उपस्थितीमुळे त्याला मदरबोर्डवरून PCIe द्विभाजन समर्थनाची आवश्यकता नाही. जरी ते X1 PCIe 1.0 स्लॉट असले तरीही ते PCIe सह सर्वात प्राचीन सिस्टीममध्ये कार्य करेल. स्वाभाविकच, योग्य वेगाने. तेथे कोणतेही RAID नाहीत. बोर्डवर कोणतेही अंगभूत BIOS नाही. त्यामुळे, तुमची सिस्टीम NVMe सह बूट करायला जादुईपणे शिकणार नाही, NVMe RAID या यंत्राबद्दल धन्यवाद.

हा घटक सिस्टीममध्ये फक्त एक विनामूल्य 8x PCIe 3.0 च्या उपस्थितीमुळे होता, आणि, जर तेथे 2 विनामूल्य स्लॉट असतील, तर ते सहजपणे दोन पेनी PEX4M2E1 किंवा अॅनालॉगसह बदलले जाऊ शकतात, जे 600 च्या किमतीत कुठेही खरेदी केले जाऊ शकतात. रुबल

सर्व प्रकारचे हार्डवेअर किंवा बिल्ट-इन चिपसेट/BIOS RAIDs नाकारणे जाणूनबुजून केले गेले, सर्व डेटा जतन करताना, SSD/HDDचा अपवाद वगळता, संपूर्ण प्रणाली पूर्णपणे बदलण्यात सक्षम होण्यासाठी. तद्वतच, जेणेकरून तुम्ही पूर्णपणे नवीन/वेगळ्या हार्डवेअरवर जाताना स्थापित ऑपरेटिंग सिस्टम देखील जतन करू शकता. मुख्य गोष्ट अशी आहे की तेथे SATA आणि PCIe पोर्ट आहेत. हे थेट सीडी किंवा बूट करण्यायोग्य फ्लॅश ड्राइव्हसारखे आहे, फक्त खूप वेगवान आणि थोडे अवजड.

विनोदअन्यथा, काय होते हे तुम्हाला माहीत आहे - काहीवेळा तुम्हाला तातडीने संपूर्ण अॅरे घेऊन जावे लागते. पण मी डेटा गमावू इच्छित नाही. हे करण्यासाठी, सर्व उल्लेखित माध्यमे मानक केसच्या 5.25 बे मधील स्लाइड्सवर सोयीस्करपणे स्थित आहेत.

ठीक आहे, आणि अर्थातच, लिनक्समध्ये एसएसडी कॅशिंगच्या विविध पद्धतींचा प्रयोग करण्यासाठी.

हार्डवेअर छापे कंटाळवाणे आहेत. हे सुरु करा. ते एकतर कार्य करते किंवा ते करत नाही. आणि mdadm सह नेहमीच पर्याय असतात.

मऊ

पूर्वी, ईओएलच्या जवळ असलेल्या हार्डवेअरवर डेबियन 8 जेसी स्थापित केले होते. RAID 6 हे LVM सह जोडलेल्या उपरोक्त नमूद केलेल्या HDDs मधून एकत्र केले गेले. हे kvm/libvirt मध्ये आभासी मशीन चालवते.

कारण पोर्टेबल बूटेबल SATA/NVMe फ्लॅश ड्राइव्हस् तयार करण्याचा लेखकाला योग्य अनुभव आहे, तसेच नेहमीच्या योग्य टेम्प्लेटमध्ये खंड पडू नये म्हणून, उबंटू 18.04 ही लक्ष्य प्रणाली म्हणून निवडली गेली होती, जी आधीच पुरेशी स्थिर झाली आहे, परंतु अद्याप 3 वर्षे आहे. भविष्यात समर्थन.

नमूद केलेल्या सिस्टममध्ये बॉक्सच्या बाहेर आम्हाला आवश्यक असलेले सर्व हार्डवेअर ड्रायव्हर्स आहेत. आम्हाला कोणत्याही तृतीय-पक्ष सॉफ्टवेअर किंवा ड्रायव्हर्सची आवश्यकता नाही.

स्थापनेची तयारी करत आहे

प्रणाली स्थापित करण्यासाठी आम्हाला उबंटू डेस्कटॉप प्रतिमा आवश्यक आहे. सर्व्हर सिस्टीममध्ये एक प्रकारचा जोमदार इंस्टॉलर आहे, जो अत्याधिक स्वातंत्र्य दर्शवितो जो UEFI सिस्टीम विभाजनाला एका डिस्कवर हलवून, सर्व सौंदर्य खराब करून अक्षम करता येत नाही. त्यानुसार, ते केवळ UEFI मोडमध्ये स्थापित केले आहे. कोणतेही पर्याय देत नाही.

यावर आम्ही आनंदी नाही.

का?दुर्दैवाने, UEFI बूट हे बूट सॉफ्टवेअर RAID शी अत्यंत खराब सुसंगत आहे, कारण... UEFI ESP विभाजनासाठी आम्हाला कोणीही आरक्षण देत नाही. ऑनलाइन रेसिपी आहेत जे यूएसबी पोर्टमध्ये फ्लॅश ड्राइव्हवर ईएसपी विभाजन ठेवण्याची सूचना देतात, परंतु हे अपयशी ठरते. मेटाडेटा आवृत्ती 1 सह सॉफ्टवेअर mdadm RAID 0.9 वापरत असलेल्या पाककृती आहेत ज्या UEFI BIOS ला हे विभाजन पाहण्यापासून प्रतिबंधित करत नाहीत, परंतु BIOS किंवा दुसरे हार्डवेअर OS ESP ला काहीतरी लिहिते आणि ते इतरांशी सिंक्रोनाइझ करणे विसरते तेव्हापर्यंत हे आनंददायी क्षण टिकते. आरसे

याव्यतिरिक्त, UEFI बूट NVRAM वर अवलंबून आहे, जे डिस्कसह नवीन सिस्टममध्ये हलणार नाही, कारण मदरबोर्डचा भाग आहे.

म्हणून, आम्ही नवीन चाक शोधून काढणार नाही. आमच्याकडे आधीच तयार केलेली, वेळ-चाचणी केलेली आजोबांची बाइक आहे, ज्याला आता Legacy/BIOS बूट म्हणतात, UEFI-सुसंगत प्रणालींवर CSM चे अभिमानास्पद नाव आहे. आम्ही ते फक्त शेल्फमधून काढू, वंगण घालू, टायर पंप करू आणि ओलसर कापडाने पुसून टाकू.

उबंटूची डेस्कटॉप आवृत्ती देखील लीगेसी बूटलोडरसह योग्यरित्या स्थापित केली जाऊ शकत नाही, परंतु येथे, जसे ते म्हणतात, किमान पर्याय आहेत.

आणि म्हणून, आम्ही हार्डवेअर गोळा करतो आणि उबंटू लाइव्ह बूट करण्यायोग्य फ्लॅश ड्राइव्हवरून सिस्टम लोड करतो. आम्हाला पॅकेज डाउनलोड करावे लागतील, म्हणून आम्ही तुमच्यासाठी काम करणारे नेटवर्क सेट करू. जर ते कार्य करत नसेल, तर तुम्ही आवश्यक पॅकेजेस फ्लॅश ड्राइव्हवर अगोदर लोड करू शकता.

आम्ही डेस्कटॉप वातावरणात जातो, टर्मिनल एमुलेटर लाँच करतो आणि पुढे जातो:

#sudo bash

कसे…?वरील ओळ sudo बद्दल holiwars साठी प्रामाणिक ट्रिगर आहे. क बоमोठ्या संधी येतात आणिоजास्त जबाबदारी. आपण ते स्वतःवर घेऊ शकता का हा प्रश्न आहे. बर्‍याच लोकांना असे वाटते की अशा प्रकारे सुडो वापरणे कमीतकमी काळजी घेणे नाही. तथापि:

#apt-get install mdadm lvm2 thin-provisioning-tools btrfs-tools util-linux lsscsi nvme-cli mc

ZFS का नाही...?जेव्हा आम्ही आमच्या संगणकावर सॉफ्टवेअर स्थापित करतो, तेव्हा आम्ही मूलत: आमचे हार्डवेअर या सॉफ्टवेअरच्या विकसकांना चालविण्यास देतो.
जेव्हा आम्ही आमच्या डेटाच्या सुरक्षिततेसह या सॉफ्टवेअरवर विश्वास ठेवतो, तेव्हा आम्ही हा डेटा पुनर्संचयित करण्याच्या खर्चाइतके कर्ज घेतो, ज्याची आम्हाला एक दिवस परतफेड करावी लागेल.

या दृष्टिकोनातून, ZFS ही फेरारी आहे आणि mdadm+lvm ही सायकलसारखी आहे.

व्यक्तिनिष्ठपणे, लेखकाने फेरारीऐवजी अज्ञात व्यक्तींना बाईक क्रेडिटवर देणे पसंत केले आहे. तेथे, अंकाची किंमत जास्त नाही. अधिकारांची गरज नाही. वाहतूक नियमांपेक्षा सोपे. पार्किंग मोफत आहे. क्रॉस-कंट्री क्षमता अधिक चांगली आहे. आपण नेहमी सायकलला पाय जोडू शकता आणि आपण आपल्या स्वत: च्या हातांनी सायकल दुरुस्त करू शकता.

मग BTRFS का...?ऑपरेटिंग सिस्टम बूट करण्यासाठी, आम्हाला बॉक्सच्या बाहेर लेगसी/BIOS GRUB मध्ये सपोर्ट असलेली फाइल सिस्टम आवश्यक आहे आणि त्याच वेळी थेट स्नॅपशॉटचे समर्थन करते. आपण ते /boot विभाजनासाठी वापरू. याशिवाय, लेखक हे FS/ (रूट) साठी वापरण्यास प्राधान्य देतो, हे लक्षात घेण्यास विसरू नका की इतर कोणत्याही सॉफ्टवेअरसाठी तुम्ही LVM वर स्वतंत्र विभाजने तयार करू शकता आणि त्यांना आवश्यक डिरेक्ट्रीमध्ये माउंट करू शकता.

आम्ही या FS वर व्हर्च्युअल मशीन किंवा डेटाबेसच्या कोणत्याही प्रतिमा संचयित करणार नाही.
हे FS फक्त सिस्टीमचे स्नॅपशॉट्स बंद न करता तयार करण्यासाठी वापरले जाईल आणि नंतर हे स्नॅपशॉट पाठवा/प्राप्त करून बॅकअप डिस्कवर हस्तांतरित करा.

याशिवाय, लेखक साधारणपणे हार्डवेअरवर किमान सॉफ्टवेअर ठेवण्यास आणि इतर सर्व सॉफ्टवेअर्स व्हर्च्युअल मशीनमध्ये चालवण्यास प्राधान्य देतो जसे की GPUs आणि PCI-USB होस्ट कंट्रोलर IOMMU द्वारे KVM वर फॉरवर्ड करणे.

हार्डवेअरवर फक्त डेटा स्टोरेज, व्हर्च्युअलायझेशन आणि बॅकअप या गोष्टी उरल्या आहेत.

जर तुमचा ZFS वर अधिक विश्वास असेल तर, तत्त्वतः, निर्दिष्ट अनुप्रयोगासाठी ते अदलाबदल करण्यायोग्य आहेत.

तथापि, ZFS, BRTFS आणि LVM मध्ये असलेल्या अंगभूत मिररिंग/RAID आणि रिडंडंसी वैशिष्ट्यांकडे लेखक जाणीवपूर्वक दुर्लक्ष करतो.

अतिरिक्त युक्तिवाद म्हणून, BTRFS मध्ये यादृच्छिक लेखन अनुक्रमिक लेखनात बदलण्याची क्षमता आहे, ज्याचा HDD वर स्नॅपशॉट/बॅकअप समक्रमित करण्याच्या गतीवर अत्यंत सकारात्मक प्रभाव पडतो.

चला सर्व उपकरणे पुन्हा स्कॅन करूया:

#udevadm control --reload-rules && udevadm trigger

चला आजूबाजूला एक नजर टाकूया:

#lsscsi && nvme list
[0:0:0:0] disk ATA Samsung SSD 860 2B6Q /dev/sda
[1:0:0:0] disk ATA Samsung SSD 860 2B6Q /dev/sdb
[2:0:0:0] disk ATA Samsung SSD 860 2B6Q /dev/sdc
[3:0:0:0] disk ATA Samsung SSD 860 2B6Q /dev/sdd
[4:0:0:0] disk ATA Samsung SSD 860 2B6Q /dev/sde
[5:0:0:0] disk ATA Samsung SSD 860 2B6Q /dev/sdf
[6:0:0:0] disk ATA HGST HTS721010A9 A3J0 /dev/sdg
[6:0:1:0] disk ATA HGST HTS721010A9 A3J0 /dev/sdh
[6:0:2:0] disk ATA HGST HTS721010A9 A3J0 /dev/sdi
[6:0:3:0] disk ATA HGST HTS721010A9 A3B0 /dev/sdj
[6:0:4:0] disk ATA HGST HTS721010A9 A3B0 /dev/sdk
[6:0:5:0] disk ATA HGST HTS721010A9 A3B0 /dev/sdl
[6:0:6:0] disk ATA HGST HTS721010A9 A3J0 /dev/sdm
[6:0:7:0] disk ATA HGST HTS721010A9 A3J0 /dev/sdn
Node SN Model Namespace Usage Format FW Rev
---------------- -------------------- ---------------------------------------- --------- -------------------------- ---------------- --------
/dev/nvme0n1 S466NXXXXXXX15L Samsung SSD 970 EVO 500GB 1 0,00 GB / 500,11 GB 512 B + 0 B 2B2QEXE7
/dev/nvme1n1 S5H7NXXXXXXX48N Samsung SSD 970 EVO 500GB 1 0,00 GB / 500,11 GB 512 B + 0 B 2B2QEXE7


डिस्क लेआउट

एनवीएमए एसएसडी

परंतु आम्ही त्यांना कोणत्याही प्रकारे चिन्हांकित करणार नाही. त्याचप्रमाणे, आमच्या BIOS ला या ड्राइव्ह दिसत नाहीत. त्यामुळे, ते पूर्णपणे सॉफ्टवेअर RAID वर जातील. आम्ही तेथे विभाग देखील तयार करणार नाही. तुम्हाला “कॅनन” किंवा “मुख्यतः” फॉलो करायचे असल्यास, HDD सारखे एक मोठे विभाजन तयार करा.

सटा एचडीडी

येथे विशेष काही शोधण्याची गरज नाही. आम्ही प्रत्येक गोष्टीसाठी एक विभाग तयार करू. आम्ही विभाजन तयार करू कारण BIOS या डिस्क्स पाहतो आणि त्यांच्यापासून बूट करण्याचा प्रयत्न देखील करू शकतो. आम्ही नंतर या डिस्क्सवर GRUB देखील स्थापित करू जेणेकरून सिस्टम अचानक हे करू शकेल.

#cat >hdd.part << EOF
label: dos
label-id: 0x00000000
device: /dev/sdg
unit: sectors

/dev/sdg1 : start= 2048, size= 1953523120, type=fd, bootable
EOF
#sfdisk /dev/sdg < hdd.part
#sfdisk /dev/sdh < hdd.part
#sfdisk /dev/sdi < hdd.part
#sfdisk /dev/sdj < hdd.part
#sfdisk /dev/sdk < hdd.part
#sfdisk /dev/sdl < hdd.part
#sfdisk /dev/sdm < hdd.part
#sfdisk /dev/sdn < hdd.part


SATA SSD

इथेच गोष्टी आमच्यासाठी मनोरंजक होतात.

प्रथम, आमचे ड्राइव्ह 2 टीबी आकाराचे आहेत. हे MBR साठी स्वीकार्य श्रेणीमध्ये आहे, जे आम्ही वापरणार आहोत. आवश्यक असल्यास, GPT सह बदलले जाऊ शकते. GPT डिस्क्समध्ये एक सुसंगतता स्तर असतो जो MBR-सुसंगत प्रणालींना प्रथम 4 विभाजने पहिल्या 2 टेराबाइट्समध्ये स्थित असल्यास ते पाहण्याची परवानगी देतो. मुख्य गोष्ट अशी आहे की या डिस्क्सवरील बूट विभाजन आणि बायोस_ग्रब विभाजन सुरुवातीला असावे. हे तुम्हाला GPT लेगसी/BIOS ड्राइव्हस्वरून बूट करण्याची परवानगी देते.

पण हे आमचे प्रकरण नाही.

येथे आपण दोन विभाग तयार करू. पहिला आकार 1 GB असेल आणि RAID 1 /boot साठी वापरला जाईल.

दुसरा RAID 6 साठी वापरला जाईल आणि ड्राइव्हच्या शेवटी वाटप न केलेले लहान क्षेत्र वगळता उर्वरित सर्व मोकळी जागा घेईल.

हे अचिन्हांकित क्षेत्र कोणते आहे?नेटवर्कवरील स्त्रोतांनुसार, आमच्या SATA SSDs मध्ये 6 ते 78 गीगाबाइट्सच्या आकारात डायनॅमिकली एक्सपांडेबल SLC कॅशे आहे. ड्राइव्हच्या डेटा शीटमध्ये "गीगाबाइट्स" आणि "गीबिबाइट्स" मधील फरकामुळे आम्हाला 6 गीगाबाइट्स “विनामूल्य” मिळतात. उर्वरित 72 गीगाबाइट्स न वापरलेल्या जागेतून वाटप केले जातात.

येथे हे लक्षात घेतले पाहिजे की आमच्याकडे एसएलसी कॅशे आहे आणि जागा 4 बिट एमएलसी मोडमध्ये व्यापलेली आहे. ज्याचा आमच्यासाठी प्रभावी अर्थ असा आहे की प्रत्येक 4 गीगाबाइट मोकळ्या जागेसाठी आम्हाला फक्त 1 गीगाबाइट SLC कॅशे मिळेल.

72 गीगाबाइट्सचा 4 ने गुणाकार करा आणि 288 गीगाबाइट मिळवा. ही मोकळी जागा आहे जी आम्ही ड्राइव्हला SLC कॅशेचा पूर्ण वापर करण्यास अनुमती देण्यासाठी चिन्हांकित करणार नाही.

अशा प्रकारे, आम्ही एकूण सहा ड्राईव्हमधून 312 गीगाबाइट्सपर्यंत एसएलसी कॅशे प्रभावीपणे मिळवू. सर्व ड्राइव्हपैकी, 2 रिडंडंसीसाठी RAID मध्ये वापरले जातील.

कॅशेची ही रक्कम आपल्याला वास्तविक जीवनात अत्यंत क्वचितच अशा परिस्थितीचा सामना करण्यास अनुमती देईल जिथे लेखन कॅशेमध्ये जात नाही. हे QLC मेमरीच्या सर्वात दुःखद दोषाची भरपाई करते - जेव्हा कॅशेला बायपास करून डेटा लिहिला जातो तेव्हा अत्यंत कमी लेखन गती. जर तुमचे भार याच्याशी जुळत नसतील, तर मी शिफारस करतो की तुम्ही डेटा शीटमधील TBW लक्षात घेऊन, अशा लोडखाली तुमचा SSD किती काळ टिकेल याचा विचार करा.

#cat >ssd.part << EOF
label: dos
label-id: 0x00000000
device: /dev/sda
unit: sectors

/dev/sda1 : start= 2048, size= 2097152, type=fd, bootable
/dev/sda2 : start= 2099200, size= 3300950016, type=fd
EOF
#sfdisk /dev/sda < ssd.part
#sfdisk /dev/sdb < ssd.part
#sfdisk /dev/sdc < ssd.part
#sfdisk /dev/sdd < ssd.part
#sfdisk /dev/sde < ssd.part
#sfdisk /dev/sdf < ssd.part


अॅरे तयार करणे

प्रथम, आपल्याला मशीनचे नाव बदलण्याची आवश्यकता आहे. हे आवश्यक आहे कारण होस्ट नाव हे mdadm च्या आत कुठेतरी अॅरे नावाचा भाग आहे आणि कुठेतरी काहीतरी प्रभावित करते. अर्थात, अॅरेचे नाव नंतर बदलले जाऊ शकते, परंतु ही एक अनावश्यक पायरी आहे.

#mcedit /etc/hostname
#mcedit /etc/hosts
#hostname
vdesk0


एनवीएमए एसएसडी

#mdadm --create --verbose --assume-clean /dev/md0 --level=1 --raid-devices=2 /dev/nvme[0-1]n1

का - गृहीत - स्वच्छ ...?अॅरे सुरू करणे टाळण्यासाठी. RAID स्तर 1 आणि 6 दोन्हीसाठी हे वैध आहे. नवीन अॅरे असल्यास प्रारंभाशिवाय सर्वकाही कार्य करू शकते. शिवाय, निर्मितीनंतर SSD अॅरे सुरू करणे म्हणजे TBW संसाधनाचा अपव्यय आहे. जमलेल्या SSD अॅरेवर "प्रारंभ" करण्यासाठी आम्ही TRIM/DISCARD वापरतो.

SSD अॅरेसाठी, RAID 1 DISCARD बॉक्सच्या बाहेर समर्थित आहे.

SSD RAID 6 डिस्कार्ड अॅरेसाठी, तुम्ही ते कर्नल मॉड्यूल पॅरामीटर्समध्ये सक्षम केले पाहिजे.

या प्रणालीतील लेव्हल 4/5/6 अॅरेमध्ये वापरल्या जाणार्‍या सर्व SSDs मध्ये discard_zeroes_data साठी कार्यरत समर्थन असल्यासच हे केले पाहिजे. काहीवेळा तुम्हाला विचित्र ड्राइव्हस् आढळतात जे कर्नलला सांगतात की हे फंक्शन समर्थित आहे, परंतु प्रत्यक्षात ते तेथे नसते किंवा फंक्शन नेहमीच कार्य करत नाही. याक्षणी, समर्थन जवळजवळ सर्वत्र उपलब्ध आहे, तथापि, त्रुटींसह जुन्या ड्राइव्ह आणि फर्मवेअर आहेत. या कारणास्तव, RAID 6 साठी DISCARD समर्थन मुलभूतरित्या अक्षम केले आहे.

लक्ष द्या, खालील आदेश "शून्य" सह अॅरे "प्रारंभ" करून NVMe ड्राइव्हवरील सर्व डेटा नष्ट करेल.

#blkdiscard /dev/md0

काहीतरी चूक झाल्यास, एक पायरी निर्दिष्ट करण्याचा प्रयत्न करा.

#blkdiscard --step 65536 /dev/md0

SATA SSD

#mdadm --create --verbose --assume-clean /dev/md1 --level=1 --raid-devices=6 /dev/sd[a-f]1
#blkdiscard /dev/md1
#mdadm --create --verbose --assume-clean /dev/md2 --chunk-size=512 --level=6 --raid-devices=6 /dev/sd[a-f]2

एवढा मोठा का...?खंड-आकार वाढवल्याने खंड-आकार समावेशीपर्यंतच्या ब्लॉक्समधील यादृच्छिक वाचनाच्या गतीवर सकारात्मक परिणाम होतो. हे घडते कारण योग्य आकाराचे किंवा त्यापेक्षा लहान ऑपरेशन एका उपकरणावर संपूर्णपणे पूर्ण केले जाऊ शकते. म्हणून, सर्व उपकरणांमधील IOPS सारांशित केले आहे. आकडेवारीनुसार, 99% IO 512K पेक्षा जास्त नाही.

RAID 6 IOPS प्रति लेखन नेहमी एका ड्राइव्हच्या IOPS पेक्षा कमी किंवा समान. जेव्हा, यादृच्छिक वाचन म्हणून, IOPS एका ड्राइव्हपेक्षा अनेक पटींनी जास्त असू शकते आणि येथे ब्लॉकचा आकार महत्त्वाचा आहे.
RAID 6 बाय-डिझाइनमध्ये खराब असलेले पॅरामीटर ऑप्टिमाइझ करण्याचा प्रयत्न करण्यात लेखकाला मुद्दा दिसत नाही आणि त्याऐवजी RAID 6 काय चांगले आहे ते ऑप्टिमाइझ करतो.
आम्ही RAID 6 च्या खराब यादृच्छिक लेखनाची भरपाई NVMe कॅशे आणि पातळ-तरतुदी युक्त्यांसह करू.

आम्ही अद्याप RAID 6 साठी DISCARD सक्षम केलेले नाही. त्यामुळे आत्ता आम्ही हा अॅरे "प्रारंभ" करणार नाही. OS स्थापित केल्यानंतर आम्ही हे नंतर करू.

सटा एचडीडी

#mdadm --create --verbose --assume-clean /dev/md3 --chunk-size=512 --level=6 --raid-devices=8 /dev/sd[g-n]1

NVMe RAID वर LVM

गतीसाठी, आम्हाला रूट फाइल सिस्टम NVMe RAID 1 वर ठेवायची आहे जी /dev/md0 आहे.
तथापि, स्वॅप, मेटाडेटा आणि LVM-कॅशे आणि LVM-पातळ मेटाडेटा यासारख्या इतर गरजांसाठी आम्हाला या जलद अॅरेची गरज असेल, त्यामुळे आम्ही या अॅरेवर LVM VG तयार करू.

#pvcreate /dev/md0
#vgcreate root /dev/md0

रूट फाइल सिस्टमसाठी विभाजन तयार करू.

#lvcreate -L 128G --name root root

चला RAM च्या आकारानुसार स्वॅपिंगसाठी एक विभाजन तयार करूया.

#lvcreate -L 32G --name swap root

OS स्थापना

एकूण, आमच्याकडे सिस्टम स्थापित करण्यासाठी आवश्यक सर्वकाही आहे.

उबंटू लाइव्ह वातावरणातून सिस्टम इंस्टॉलेशन विझार्ड लाँच करा. सामान्य स्थापना. केवळ स्थापनेसाठी डिस्क निवडण्याच्या टप्प्यावर, आपल्याला खालील निर्दिष्ट करणे आवश्यक आहे:

• /dev/md1, - माउंट पॉइंट /boot, FS - BTRFS
• /dev/root/root (उर्फ /dev/mapper/root-root), - माउंट पॉइंट / (रूट), FS - BTRFS
• /dev/root/swap (उर्फ /dev/mapper/root-swap), - स्वॅप विभाजन म्हणून वापरा
• बूटलोडर /dev/sda वर स्थापित करा

जेव्हा तुम्ही रूट फाइल सिस्टीम म्हणून BTRFS निवडता, तेव्हा इंस्टॉलर आपोआप / (रूट) साठी "@" आणि /home साठी "@home" नावाचे दोन BTRFS खंड तयार करेल.

चला इंस्टॉलेशन सुरू करूया...

बूटलोडर स्थापित करताना त्रुटी दर्शविणाऱ्या मॉडेल डायलॉग बॉक्ससह स्थापना समाप्त होईल. दुर्दैवाने, तुम्ही मानक माध्यमांचा वापर करून या संवादातून बाहेर पडू शकणार नाही आणि स्थापना सुरू ठेवू शकणार नाही. आम्ही सिस्टममधून लॉग आउट करतो आणि पुन्हा लॉग इन करतो, स्वच्छ उबंटू लाइव्ह डेस्कटॉपवर समाप्त होतो. टर्मिनल उघडा आणि पुन्हा:

#sudo bash

इंस्टॉलेशन सुरू ठेवण्यासाठी क्रोट वातावरण तयार करा:

#mkdir /mnt/chroot
#mount -o defaults,space_cache,noatime,nodiratime,discard,subvol=@ /dev/mapper/root-root /mnt/chroot
#mount -o defaults,space_cache,noatime,nodiratime,discard,subvol=@home /dev/mapper/root-root /mnt/chroot/home
#mount -o defaults,space_cache,noatime,nodiratime,discard /dev/md1 /mnt/chroot/boot
#mount --bind /proc /mnt/chroot/proc
#mount --bind /sys /mnt/chroot/sys
#mount --bind /dev /mnt/chroot/dev

chroot मध्ये नेटवर्क आणि होस्टनाव कॉन्फिगर करूया:

#cat /etc/hostname >/mnt/chroot/etc/hostname
#cat /etc/hosts >/mnt/chroot/etc/hosts
#cat /etc/resolv.conf >/mnt/chroot/etc/resolv.conf

चला chroot वातावरणात जाऊया:

#chroot /mnt/chroot

सर्व प्रथम, आम्ही पॅकेजेस वितरीत करू:

apt-get install --reinstall mdadm lvm2 thin-provisioning-tools btrfs-tools util-linux lsscsi nvme-cli mc debsums hdparm

अपूर्ण सिस्टीम इन्स्टॉलेशनमुळे कुटिलपणे स्थापित केलेली सर्व पॅकेजेस तपासू आणि निराकरण करूया:

#CORRUPTED_PACKAGES=$(debsums -s 2>&1 | awk '{print $6}' | uniq)
#apt-get install --reinstall $CORRUPTED_PACKAGES

काहीतरी कार्य करत नसल्यास, तुम्हाला प्रथम /etc/apt/sources.list संपादित करण्याची आवश्यकता असू शकते

TRIM/DISCARD सक्षम करण्यासाठी RAID 6 मॉड्यूलसाठी पॅरामीटर्स समायोजित करूया:

#cat >/etc/modprobe.d/raid456.conf << EOF
options raid456 devices_handle_discard_safely=1
EOF

चला आमच्या अ‍ॅरेमध्ये थोडासा बदल करूया:

#cat >/etc/udev/rules.d/60-md.rules << EOF
SUBSYSTEM=="block", KERNEL=="md*", ACTION=="change", TEST=="md/stripe_cache_size", ATTR{md/stripe_cache_size}="32768"
SUBSYSTEM=="block", KERNEL=="md*", ACTION=="change", TEST=="md/sync_speed_min", ATTR{md/sync_speed_min}="48000"
SUBSYSTEM=="block", KERNEL=="md*", ACTION=="change", TEST=="md/sync_speed_max", ATTR{md/sync_speed_max}="300000"
EOF
#cat >/etc/udev/rules.d/62-hdparm.rules << EOF
SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="1", RUN+="/sbin/hdparm -B 254 /dev/%k"
EOF
#cat >/etc/udev/rules.d/63-blockdev.rules << EOF
SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="1", RUN+="/sbin/blockdev --setra 1024 /dev/%k"
SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="md*", RUN+="/sbin/blockdev --setra 0 /dev/%k"
EOF

काय होतं ते..?आम्ही udev नियमांचा एक संच तयार केला आहे जो पुढील गोष्टी करेल:

• RAID 2020 साठी ब्लॉक कॅशे आकार 6 साठी पुरेसा असेल असे सेट करा. डीफॉल्ट मूल्य, असे दिसते की, Linux च्या निर्मितीपासून बदललेले नाही आणि बर्याच काळापासून पुरेसे नाही.
• अॅरे चेक/सिंक्रोनाइझेशनच्या कालावधीसाठी किमान IO राखून ठेवा. हे तुमचे अॅरे लोड अंतर्गत शाश्वत सिंक्रोनाइझेशन स्थितीत अडकण्यापासून रोखण्यासाठी आहे.
• अॅरेच्या चेक/सिंक्रोनाइझेशन दरम्यान कमाल IO मर्यादित करा. हे आवश्यक आहे जेणेकरुन SSD RAIDs चे समक्रमण/तपासणी केल्याने तुमचे ड्राइव्ह्स कुरकुरीत होणार नाहीत. हे विशेषतः NVMe साठी खरे आहे. (रेडिएटरबद्दल आठवते? मी विनोद करत नव्हते.)
• APM द्वारे स्पिंडल रोटेशन (HDD) थांबवण्यापासून डिस्क्सना प्रतिबंधित करा आणि डिस्क कंट्रोलर्ससाठी स्लीप टाइमआउट 7 तासांवर सेट करा. तुमची ड्राइव्हस् (-B 255) करू शकत असल्यास तुम्ही APM पूर्णपणे अक्षम करू शकता. डीफॉल्ट मूल्यासह, ड्राइव्हस् पाच सेकंदांनंतर थांबतील. मग OS ला डिस्क कॅशे रीसेट करायची आहे, डिस्क पुन्हा फिरतील आणि सर्वकाही पुन्हा सुरू होईल. डिस्क्समध्ये स्पिंडल रोटेशनची मर्यादित कमाल संख्या असते. अशी साधी डीफॉल्ट सायकल काही वर्षांत तुमची डिस्क सहजपणे नष्ट करू शकते. सर्व डिस्कला याचा त्रास होत नाही, परंतु आमचे "लॅपटॉप" आहेत, योग्य डीफॉल्ट सेटिंग्जसह, जे RAID ला मिनी-MAID सारखे बनवते.
• डिस्कवर रीडहेड स्थापित करा (रोटेटिंग) 1 मेगाबाइट - सलग दोन ब्लॉक्स/खंड RAID 6
• अ‍ॅरेवर स्वतःच रीडहेड अक्षम करा.

चला संपादित करूया /etc/fstab:

#cat >/etc/fstab << EOF
# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
# file-system mount-point type options dump pass
/dev/mapper/root-root / btrfs defaults,space_cache,noatime,nodiratime,discard,subvol=@ 0 1
UUID=$(blkid -o value -s UUID /dev/md1) /boot btrfs defaults,space_cache,noatime,nodiratime,discard 0 2
/dev/mapper/root-root /home btrfs defaults,space_cache,noatime,nodiratime,discard,subvol=@home 0 2
/dev/mapper/root-swap none swap sw 0 0
EOF
अस का..?आम्ही UUID द्वारे /boot विभाजन शोधू. अॅरे नामकरण सैद्धांतिकदृष्ट्या बदलू शकते.

आम्ही /dev/mapper/vg-lv नोटेशनमध्ये LVM नावांद्वारे उर्वरित विभाग शोधू, कारण ते विभाजने अगदी अद्वितीयपणे ओळखतात.

आम्ही LVM साठी UUID वापरत नाही कारण LVM व्हॉल्यूमचे UUID आणि त्यांचे स्नॅपशॉट समान असू शकतात.माउंट /dev/mapper/root-root.. दोनदा?होय. नक्की. BTRFS चे वैशिष्ट्य. ही फाइल प्रणाली वेगवेगळ्या सबव्हॉल्ससह अनेक वेळा आरोहित केली जाऊ शकते.

याच वैशिष्ट्यामुळे, मी कधीही सक्रिय BTRFS व्हॉल्यूमचे LVM स्नॅपशॉट तयार न करण्याची शिफारस करतो. तुम्ही रीबूट केल्यावर तुम्हाला आश्चर्य वाटू शकते.

चला mdadm कॉन्फिगरेशन पुन्हा निर्माण करूया:

#/usr/share/mdadm/mkconf | sed 's/#DEVICE/DEVICE/g' >/etc/mdadm/mdadm.conf

चला LVM सेटिंग्ज समायोजित करूया:

#cat >>/etc/lvm/lvmlocal.conf << EOF

activation {
thin_pool_autoextend_threshold=90
thin_pool_autoextend_percent=5
}
allocation {
cache_pool_max_chunks=2097152
}
devices {
global_filter=["r|^/dev/.*_corig$|","r|^/dev/.*_cdata$|","r|^/dev/.*_cmeta$|","r|^/dev/.*gpv$|","r|^/dev/images/.*$|","r|^/dev/mapper/images.*$|","r|^/dev/backup/.*$|","r|^/dev/mapper/backup.*$|"] issue_discards=1
}
EOF

काय होतं ते..?आम्ही व्यापलेल्या जागेच्या 90% व्हॉल्यूमच्या 5% पर्यंत पोहोचल्यानंतर LVM पातळ पूलचा स्वयंचलित विस्तार सक्षम केला आहे.

आम्ही LVM कॅशेसाठी कॅशे ब्लॉक्सची कमाल संख्या वाढवली आहे.

आम्ही LVM ला LVM व्हॉल्यूम (PV) शोधण्यापासून प्रतिबंधित केले आहे:

• LVM कॅशे (cdata) असलेली उपकरणे
• LVM कॅशे वापरून कॅशे केलेली साधने, कॅशे बायपास करून ( _कोरिग). या प्रकरणात, कॅशे केलेले डिव्हाइस स्वतः अजूनही कॅशेद्वारे स्कॅन केले जाईल (फक्त ).
• LVM कॅशे मेटाडेटा (cmeta) असलेली उपकरणे
• VG मधील सर्व उपकरणे नावाच्या प्रतिमांसह. येथे आमच्याकडे व्हर्च्युअल मशीन्सच्या डिस्क प्रतिमा असतील, आणि आम्हाला होस्टवरील LVM ने अतिथी OS चे खंड सक्रिय करायचे नाहीत.
• VG मधील सर्व उपकरणे नाव बॅकअपसह. येथे आमच्याकडे आभासी मशीन प्रतिमांच्या बॅकअप प्रती असतील.
• सर्व उपकरणे ज्यांचे नाव “gpv” ने समाप्त होते (अतिथी भौतिक खंड)

LVM VG वर मोकळी जागा मोकळी करताना आम्ही DISCARD समर्थन सक्षम केले आहे. काळजी घ्या. यामुळे SSD वरील LV हटवणे खूप वेळखाऊ होईल. हे विशेषत: SSD RAID 6 वर लागू होते. तथापि, योजनेनुसार, आम्ही पातळ तरतुदी वापरू, त्यामुळे हे आम्हाला अजिबात अडथळा आणणार नाही.

चला initramfs प्रतिमा अपडेट करूया:

#update-initramfs -u -k all

ग्रब स्थापित आणि कॉन्फिगर करा:

#apt-get install grub-pc
#apt-get purge os-prober
#dpkg-reconfigure grub-pc

आपण कोणती डिस्क निवडली पाहिजे?सर्व जे sd* आहेत. प्रणाली कोणत्याही कार्यरत SATA ड्राइव्ह किंवा SSD वरून बूट करण्यास सक्षम असणे आवश्यक आहे.

त्यांनी os-prober का जोडले..?अत्यधिक स्वातंत्र्य आणि खेळकर हातांसाठी.

RAID पैकी एक खराब अवस्थेत असल्यास ते योग्यरित्या कार्य करत नाही. या हार्डवेअरवर चालणार्‍या व्हर्च्युअल मशीनमध्ये वापरल्या जाणार्‍या विभाजनांवर ते OS शोधण्याचा प्रयत्न करते.

जर तुम्हाला त्याची गरज असेल तर तुम्ही ते सोडू शकता, परंतु वरील सर्व गोष्टी लक्षात ठेवा. मी ऑनलाइन शरारती हातांपासून मुक्त होण्यासाठी पाककृती शोधण्याची शिफारस करतो.

यासह आम्ही प्रारंभिक स्थापना पूर्ण केली आहे. नवीन स्थापित केलेल्या OS मध्ये रीबूट करण्याची वेळ आली आहे. बूट करण्यायोग्य Live CD/USB काढायला विसरू नका.

#exit
#reboot

बूट साधन म्हणून कोणतेही SATA SSDs निवडा.

SATA SSD वर LVM

या टप्प्यावर, आम्ही आधीच नवीन OS मध्ये बूट केले आहे, नेटवर्क कॉन्फिगर केले आहे, योग्य आहे, टर्मिनल एमुलेटर उघडले आहे आणि लॉन्च केले आहे:

#sudo bash

चला सुरू ठेवूया.

SATA SSD वरून अॅरे "प्रारंभ करा":

#blkdiscard /dev/md2

ते कार्य करत नसल्यास, नंतर प्रयत्न करा:

#blkdiscard --step 65536 /dev/md2
SATA SSD वर LVM VG तयार करा:

#pvcreate /dev/md2
#vgcreate data /dev/md2

दुसरी व्हीजी का..?खरं तर, आमच्याकडे आधीपासून रूट नावाचा व्हीजी आहे. सर्व काही एका VG मध्ये का जोडू नये?

VG मध्ये अनेक PV असल्यास, VG योग्यरित्या सक्रिय होण्यासाठी, सर्व PV उपस्थित असणे आवश्यक आहे (ऑनलाइन). अपवाद LVM RAID आहे, ज्याचा आपण जाणूनबुजून वापर करत नाही.

RAID 6 अ‍ॅरेपैकी कोणत्याही ‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍डेटा गमावल्यास, ऑपरेटिंग सिस्‍टम साधारणपणे बूट होईल आणि आम्‍हाला समस्‍या सोडवण्‍याची संधी देण्‍याची आमची मनापासून इच्छा आहे.

हे करण्यासाठी, अमूर्ततेच्या पहिल्या स्तरावर आम्ही प्रत्येक प्रकारच्या भौतिक "मीडिया" वेगळ्या VG मध्ये वेगळे करू.

वैज्ञानिकदृष्ट्या, भिन्न RAID अॅरे वेगवेगळ्या "विश्वसनीयता डोमेन" च्या आहेत. तुम्ही त्यांना एका VG मध्ये क्रॅम करून त्यांच्यासाठी अपयशाचा अतिरिक्त सामान्य मुद्दा तयार करू नये.

"हार्डवेअर" स्तरावर LVM ची उपस्थिती आम्हाला वेगवेगळ्या RAID अॅरेचे तुकडे वेगवेगळ्या प्रकारे एकत्र करून कट करू देते. उदाहरणार्थ - चालवा त्याच वेळी bcache + LVM thin, bcache + BTRFS, LVM कॅशे + LVM पातळ, कॅशेसह एक जटिल ZFS कॉन्फिगरेशन किंवा या सर्वांची तुलना करून पाहण्यासाठी इतर कोणतेही नरक मिश्रण.

"हार्डवेअर" स्तरावर, आम्ही चांगल्या जुन्या "जाड" LVM व्हॉल्यूम्सशिवाय दुसरे काहीही वापरणार नाही. या नियमाचा अपवाद बॅकअप विभाजन असू शकतो.

मला असे वाटते की या क्षणापर्यंत, बर्याच वाचकांनी आधीच घरट्याच्या बाहुलीबद्दल काहीतरी शंका घेण्यास सुरुवात केली होती.

SATA HDD वर LVM

#pvcreate /dev/md3
#vgcreate backup /dev/md3

पुन्हा नवीन VG..?आम्ही डेटा बॅकअपसाठी वापरत असलेला डिस्क अ‍ॅरे अयशस्वी झाल्यास, आमची ऑपरेटिंग सिस्टीम नेहमीप्रमाणे बॅकअप नसलेल्या डेटामध्ये प्रवेश राखून सामान्यपणे कार्य करणे सुरू ठेवू इच्छितो. म्हणून, VG सक्रियकरण समस्या टाळण्यासाठी, आम्ही एक वेगळा VG तयार करतो.

LVM कॅशे सेट करत आहे

कॅशिंग उपकरण म्हणून वापरण्यासाठी NVMe RAID 1 वर LV तयार करू.

#lvcreate -L 70871154688B --name cache root

इतके कमी का आहे...?वस्तुस्थिती अशी आहे की आमच्या NVMe SSD मध्ये SLC कॅशे देखील आहे. 4-बिट MLC मध्ये व्यापलेल्या मोकळ्या जागेमुळे 18 गीगाबाइट्स “फ्री” आणि 3 गीगाबाइट डायनॅमिक. एकदा ही कॅशे संपली की, NVMe SSDs कॅशेसह आमच्या SATA SSD पेक्षा जास्त वेगवान होणार नाहीत. वास्तविक, या कारणास्तव, आमच्यासाठी LVM कॅशे विभाजन NVMe ड्राइव्हच्या SLC कॅशेच्या आकारापेक्षा दुप्पट मोठे करण्यात काही अर्थ नाही. वापरलेल्या NVMe ड्राइव्हसाठी, लेखकाने 32-64 गीगाबाइट्स कॅशे बनवणे वाजवी मानले आहे.

64 गीगाबाइट्स कॅशे, कॅशे मेटाडेटा आणि मेटाडेटा बॅकअप आयोजित करण्यासाठी दिलेला विभाजन आकार आवश्यक आहे.

याव्यतिरिक्त, मी लक्षात घेते की घाणेरड्या प्रणाली बंद केल्यानंतर, LVM संपूर्ण कॅशेला गलिच्छ म्हणून चिन्हांकित करेल आणि पुन्हा समक्रमित करेल. शिवाय, सिस्टम पुन्हा रीबूट होईपर्यंत या डिव्हाइसवर प्रत्येक वेळी lvchange वापरल्यावर याची पुनरावृत्ती होईल. म्हणून, मी योग्य स्क्रिप्ट वापरून त्वरित कॅशे पुन्हा तयार करण्याची शिफारस करतो.

कॅशे केलेले उपकरण म्हणून वापरण्यासाठी SATA RAID 6 वर LV तयार करू.

#lvcreate -L 3298543271936B --name cache data

फक्त तीन टेराबाइट्स का..?जेणेकरून, आवश्यक असल्यास, तुम्ही इतर काही गरजांसाठी SATA SSD RAID 6 वापरू शकता. कॅशे केलेल्या जागेचा आकार सिस्टीम न थांबवता, गतीशीलपणे वाढविला जाऊ शकतो. हे करण्यासाठी, तुम्हाला तात्पुरते थांबवणे आणि कॅशे पुन्हा-सक्षम करणे आवश्यक आहे, परंतु LVM-कॅशे ओव्हरचा विशिष्ट फायदा, उदाहरणार्थ, bcache हा आहे की हे फ्लायवर केले जाऊ शकते.

कॅशिंगसाठी नवीन VG तयार करू.

#pvcreate /dev/root/cache
#pvcreate /dev/data/cache
#vgcreate cache /dev/root/cache /dev/data/cache

कॅशे केलेल्या उपकरणावर LV तयार करू.

#lvcreate -L 3298539077632B --name cachedata cache /dev/data/cache

येथे आम्ही /dev/data/cache वरील सर्व मोकळी जागा ताबडतोब घेतली ज्यामुळे इतर सर्व आवश्यक विभाजने /dev/root/cache वर त्वरित तयार होतील. आपण चुकीच्या ठिकाणी काहीतरी तयार केले असल्यास, आपण pvmove वापरून ते हलवू शकता.

चला कॅशे तयार आणि सक्षम करूया:

#lvcreate -y -L 64G -n cache cache /dev/root/cache
#lvcreate -y -L 1G -n cachemeta cache /dev/root/cache
#lvconvert -y --type cache-pool --cachemode writeback --chunksize 64k --poolmetadata cache/cachemeta cache/cache
#lvconvert -y --type cache --cachepool cache/cache cache/cachedata

असा चंकसाईज का..?व्यावहारिक प्रयोगांद्वारे, लेखक हे शोधण्यात सक्षम होते की LVM कॅशे ब्लॉकचा आकार LVM पातळ ब्लॉकच्या आकाराशी जुळल्यास सर्वोत्तम परिणाम प्राप्त होतो. शिवाय, आकार जितका लहान असेल तितके यादृच्छिक रेकॉर्डिंगमध्ये कॉन्फिगरेशन चांगले कार्य करते.

64k हा LVM थिनसाठी परवानगी असलेला किमान ब्लॉक आकार आहे.

जपून लिहा..!होय. या प्रकारची कॅशे कॅशे केलेल्या डिव्हाइसवर सिंक्रोनाइझेशन लिहिण्यास स्थगित करते. याचा अर्थ कॅशे गमावल्यास, आपण कॅशे केलेल्या डिव्हाइसवरील डेटा गमावू शकता. या जोखमीची भरपाई करण्यासाठी NVMe RAID 1 व्यतिरिक्त कोणते उपाय केले जाऊ शकतात हे नंतर लेखक तुम्हाला सांगतील.

हा कॅशे प्रकार RAID 6 च्या खराब यादृच्छिक लेखन कार्यक्षमतेची भरपाई करण्यासाठी हेतुपुरस्सर निवडला गेला.

आम्हाला काय मिळाले ते तपासूया:

#lvs -a -o lv_name,lv_size,devices --units B cache
LV LSize Devices
[cache] 68719476736B cache_cdata(0)
[cache_cdata] 68719476736B /dev/root/cache(0)
[cache_cmeta] 1073741824B /dev/root/cache(16384)
cachedata 3298539077632B cachedata_corig(0)
[cachedata_corig] 3298539077632B /dev/data/cache(0)
[lvol0_pmspare] 1073741824B /dev/root/cache(16640)

फक्त [cachedata_corig] /dev/data/cache वर स्थित असावा. जर काही चूक असेल तर pvmove वापरा.

एका आदेशाने आवश्यक असल्यास आपण कॅशे अक्षम करू शकता:

#lvconvert -y --uncache cache/cachedata

हे ऑनलाइन केले जाते. LVM कॅशेला डिस्कवर समक्रमित करेल, ते काढून टाकेल, आणि cachedata_corig पुन्हा कॅशेडेटामध्ये पुनर्नामित करेल.

LVM पातळ सेट करत आहे

LVM पातळ मेटाडेटासाठी आपल्याला किती जागा आवश्यक आहे याचा अंदाजे अंदाज घेऊया:

#thin_metadata_size --block-size=64k --pool-size=6terabytes --max-thins=100000 -u bytes
thin_metadata_size - 3385794560 bytes estimated metadata area size for "--block-size=64kibibytes --pool-size=6terabytes --max-thins=100000"

4 गीगाबाइट पर्यंत राउंड: 4294967296B

दोन ने गुणा आणि LVM PV मेटाडेटा साठी 4194304B जोडा: 8594128896B
LVM पातळ मेटाडेटा आणि त्यांची बॅकअप प्रत ठेवण्यासाठी NVMe RAID 1 वर वेगळे विभाजन तयार करूया:

#lvcreate -L 8594128896B --name images root

कशासाठी..?येथे प्रश्न उद्भवू शकतो: LVM पातळ मेटाडेटा स्वतंत्रपणे का ठेवावा जर तो अजूनही NVMe वर कॅश केला जाईल आणि त्वरीत कार्य करेल.

येथे वेग महत्त्वाचा असला तरी ते मुख्य कारणापासून दूर आहे. गोष्ट अशी आहे की कॅशे अपयशाचा एक बिंदू आहे. त्यात काहीतरी घडू शकते, आणि जर LVM पातळ मेटाडेटा कॅशे केला असेल, तर सर्वकाही पूर्णपणे नष्ट होईल. संपूर्ण मेटाडेटाशिवाय, पातळ व्हॉल्यूम एकत्र करणे जवळजवळ अशक्य होईल.

मेटाडेटा वेगळ्या नॉन-कॅशेड, परंतु वेगवान, व्हॉल्यूममध्ये हलवून, आम्ही कॅशे गमावल्यास किंवा खराब झाल्यास मेटाडेटाच्या सुरक्षिततेची हमी देतो. या प्रकरणात, कॅशेच्या नुकसानामुळे होणारे सर्व नुकसान पातळ व्हॉल्यूममध्ये स्थानिकीकृत केले जाईल, जे परिमाणांच्या ऑर्डरद्वारे पुनर्प्राप्ती प्रक्रिया सुलभ करेल. उच्च संभाव्यतेसह, हे नुकसान FS लॉग वापरून पुनर्संचयित केले जाईल.

शिवाय, जर याआधी पातळ व्हॉल्यूमचा स्नॅपशॉट घेतला असेल आणि त्यानंतर कॅशे किमान एकदा पूर्णपणे सिंक्रोनाइझ झाला असेल, तर, एलव्हीएम थिनच्या अंतर्गत डिझाइनमुळे, कॅशे गमावल्यास स्नॅपशॉटच्या अखंडतेची हमी दिली जाईल. .

चला एक नवीन VG तयार करू जे पातळ-तरतुदीसाठी जबाबदार असेल:

#pvcreate /dev/root/images
#pvcreate /dev/cache/cachedata
#vgcreate images /dev/root/images /dev/cache/cachedata
चला एक पूल तयार करूया:

#lvcreate -L 274877906944B --poolmetadataspare y --poolmetadatasize 4294967296B --chunksize 64k -Z y -T images/thin-pool
का -Zyहा मोड प्रत्यक्षात कशासाठी आहे - स्पेसचे पुनर्वितरण करताना एका व्हर्च्युअल मशीनमधील डेटा दुसर्‍या व्हर्च्युअल मशीनवर लीक होण्यापासून रोखण्यासाठी - 64k पेक्षा लहान ब्लॉक्समध्ये यादृच्छिक लेखनाचा वेग वाढवण्यासाठी शून्यिंगचा वापर केला जातो. पातळ व्हॉल्यूमच्या पूर्वी न वाटलेल्या क्षेत्रामध्ये 64k पेक्षा कमी लेखन कॅशेमध्ये 64K एज-संरेखित होईल. हे कॅशे केलेल्या डिव्हाइसला बायपास करून संपूर्णपणे कॅशेद्वारे ऑपरेशन करण्यास अनुमती देईल.

चला LVs ला संबंधित PV वर हलवू:

#pvmove -n images/thin-pool_tdata /dev/root/images /dev/cache/cachedata
#pvmove -n images/lvol0_pmspare /dev/cache/cachedata /dev/root/images
#pvmove -n images/thin-pool_tmeta /dev/cache/cachedata /dev/root/images

चला तपासूया:

#lvs -a -o lv_name,lv_size,devices --units B images
LV LSize Devices
[lvol0_pmspare] 4294967296B /dev/root/images(0)
thin-pool 274877906944B thin-pool_tdata(0)
[thin-pool_tdata] 274877906944B /dev/cache/cachedata(0)
[thin-pool_tmeta] 4294967296B /dev/root/images(1024)

चाचण्यांसाठी पातळ व्हॉल्यूम तयार करूया:

#lvcreate -V 64G --thin-pool thin-pool --name test images

आम्ही चाचण्या आणि निरीक्षणासाठी पॅकेजेस स्थापित करू:

#apt-get install sysstat fio

रिअल टाइममध्ये तुम्ही आमच्या स्टोरेज कॉन्फिगरेशनच्या वर्तनाचे निरीक्षण करू शकता:

#watch 'lvs --rows --reportformat basic --quiet -ocache_dirty_blocks,cache_settings cache/cachedata && (lvdisplay cache/cachedata | grep Cache) && (sar -p -d 2 1 | grep -E "sd|nvme|DEV|md1|md2|md3|md0" | grep -v Average | sort)'

आम्ही आमच्या कॉन्फिगरेशनची चाचणी अशा प्रकारे करू शकतो:

#fio --loops=1 --size=64G --runtime=4 --filename=/dev/images/test --stonewall --ioengine=libaio --direct=1
--name=4kQD32read --bs=4k --iodepth=32 --rw=randread
--name=8kQD32read --bs=8k --iodepth=32 --rw=randread
--name=16kQD32read --bs=16k --iodepth=32 --rw=randread
--name=32KQD32read --bs=32k --iodepth=32 --rw=randread
--name=64KQD32read --bs=64k --iodepth=32 --rw=randread
--name=128KQD32read --bs=128k --iodepth=32 --rw=randread
--name=256KQD32read --bs=256k --iodepth=32 --rw=randread
--name=512KQD32read --bs=512k --iodepth=32 --rw=randread
--name=4Kread --bs=4k --rw=read
--name=8Kread --bs=8k --rw=read
--name=16Kread --bs=16k --rw=read
--name=32Kread --bs=32k --rw=read
--name=64Kread --bs=64k --rw=read
--name=128Kread --bs=128k --rw=read
--name=256Kread --bs=256k --rw=read
--name=512Kread --bs=512k --rw=read
--name=Seqread --bs=1m --rw=read
--name=Longread --bs=8m --rw=read
--name=Longwrite --bs=8m --rw=write
--name=Seqwrite --bs=1m --rw=write
--name=512Kwrite --bs=512k --rw=write
--name=256write --bs=256k --rw=write
--name=128write --bs=128k --rw=write
--name=64write --bs=64k --rw=write
--name=32write --bs=32k --rw=write
--name=16write --bs=16k --rw=write
--name=8write --bs=8k --rw=write
--name=4write --bs=4k --rw=write
--name=512KQD32write --bs=512k --iodepth=32 --rw=randwrite
--name=256KQD32write --bs=256k --iodepth=32 --rw=randwrite
--name=128KQD32write --bs=128k --iodepth=32 --rw=randwrite
--name=64KQD32write --bs=64k --iodepth=32 --rw=randwrite
--name=32KQD32write --bs=32k --iodepth=32 --rw=randwrite
--name=16KQD32write --bs=16k --iodepth=32 --rw=randwrite
--name=8KQD32write --bs=8k --iodepth=32 --rw=randwrite
--name=4kQD32write --bs=4k --iodepth=32 --rw=randwrite
| grep -E 'read|write|test' | grep -v ioengine

काळजीपूर्वक! संसाधन!हा कोड 36 वेगवेगळ्या चाचण्या चालवेल, प्रत्येक 4 सेकंदांसाठी चालेल. निम्म्या चाचण्या रेकॉर्डिंगसाठी आहेत. तुम्ही NVMe वर 4 सेकंदात बरेच काही रेकॉर्ड करू शकता. प्रति सेकंद 3 गीगाबाइट्स पर्यंत. तर, प्रत्येक रन लेखन चाचण्या तुमच्याकडून 216 गीगाबाइट्स पर्यंत SSD संसाधन खाऊ शकतात.

वाचन आणि लेखन मिश्रित?होय. वाचन आणि लेखन चाचण्या स्वतंत्रपणे चालवण्यात अर्थ आहे. शिवाय, सर्व कॅशे सिंक्रोनाइझ केले आहेत याची खात्री करणे अर्थपूर्ण आहे जेणेकरुन पूर्वी केलेले लेखन वाचनावर परिणाम करणार नाही.

कॅशे आणि पातळ व्हॉल्यूम भरल्यामुळे पहिल्या लॉन्च दरम्यान आणि त्यानंतरच्या परिणामांमध्ये मोठ्या प्रमाणात बदल होईल आणि सिस्टमने शेवटच्या लॉन्च दरम्यान भरलेले कॅशे सिंक्रोनाइझ करण्यात व्यवस्थापित केले आहे की नाही यावर देखील अवलंबून आहे.

इतर गोष्टींबरोबरच, मी आधीच पूर्ण पातळ व्हॉल्यूमवर वेग मोजण्याची शिफारस करतो ज्यामधून स्नॅपशॉट नुकताच घेतला गेला होता. पहिला स्नॅपशॉट तयार केल्यानंतर लगेचच यादृच्छिक लेखन कसे वेगवान होते हे पाहण्याची लेखकाला संधी होती, विशेषत: जेव्हा कॅशे अद्याप पूर्णपणे भरलेला नसतो. हे कॉपी-ऑन-राइट लेखन शब्दार्थ, कॅशे आणि पातळ व्हॉल्यूम ब्लॉक्सचे संरेखन आणि RAID 6 वरील यादृच्छिक लेखन RAID 6 वरून यादृच्छिक वाचनात बदलते आणि त्यानंतर कॅशेवर लिहिणे यामुळे घडते. आमच्या कॉन्फिगरेशनमध्ये, RAID 6 वरून यादृच्छिक वाचन लेखनापेक्षा 6 पट (अॅरेमधील SATA SSDs ची संख्या) जलद आहे. कारण CoW साठी ब्लॉक्स एका पातळ पूलमधून अनुक्रमे वाटप केले जातात, नंतर रेकॉर्डिंग, बहुतेक भागांसाठी, अनुक्रमिक देखील बनते.

या दोन्ही वैशिष्ट्यांचा आपल्या फायद्यासाठी वापर केला जाऊ शकतो.

कॅशे "सुसंगत" स्नॅपशॉट

कॅशेचे नुकसान/नुकसान झाल्यास डेटा गमावण्याचा धोका कमी करण्यासाठी, लेखकाने या प्रकरणात त्यांच्या अखंडतेची हमी देण्यासाठी स्नॅपशॉट फिरवण्याचा सराव सुरू करण्याचा प्रस्ताव दिला आहे.

प्रथम, थिन व्हॉल्यूम मेटाडेटा अनकॅश डिव्हाइसवर राहत असल्याने, मेटाडेटा सुसंगत असेल आणि संभाव्य नुकसान डेटा ब्लॉक्समध्ये वेगळे केले जाईल.

खालील स्नॅपशॉट रोटेशन सायकल कॅशे गमावल्यास स्नॅपशॉटमधील डेटाच्या अखंडतेची हमी देते:

1. <name> नावाच्या प्रत्येक पातळ व्हॉल्यूमसाठी, <name>.cached नावाचा स्नॅपशॉट तयार करा
2. वाजवी उच्च मूल्यावर स्थलांतर थ्रेशोल्ड सेट करूया: #lvchange --quiet --cachesettings "migration_threshold=16384" cache/cachedata
3. लूपमध्ये आम्ही कॅशेमधील गलिच्छ ब्लॉक्सची संख्या तपासतो: #lvs --rows --reportformat basic --quiet -ocache_dirty_blocks cache/cachedata | awk '{print $2}' जोपर्यंत आम्हाला शून्य मिळत नाही. जर शून्य बराच काळ गहाळ असेल, तर कॅशेला राइटथ्रू मोडवर तात्पुरते स्विच करून ते तयार केले जाऊ शकते. तथापि, आमच्या SATA आणि NVMe SSD अ‍ॅरेची गती वैशिष्ट्ये तसेच त्यांचे TBW संसाधन लक्षात घेऊन, तुम्ही एकतर कॅशे मोड न बदलता क्षण पटकन पकडण्यात सक्षम व्हाल किंवा तुमचे हार्डवेअर त्याचे संपूर्ण संसाधन पूर्णपणे खाऊन टाकेल. काही दिवस. संसाधनांच्या मर्यादांमुळे, सिस्टीम, तत्त्वतः, 100% लेखन लोडच्या खाली नेहमीच अक्षम आहे. आमचे NVMe SSDs 100% लेखन लोड अंतर्गत संसाधन पूर्णपणे संपवतील २- 3-4 दिवस. SATA SSDs फक्त दुप्पट काळ टिकतील. म्हणून, आम्ही असे गृहीत धरू की बहुतेक भार वाचनावर जातो आणि आमच्याकडे तुलनेने अल्प-मुदतीतील अत्यंत उच्च क्रियाकलापांचा स्फोट आहे आणि लेखनासाठी सरासरी कमी लोड आहे.
4. जसे आम्ही शून्य पकडले (किंवा केले), आम्ही <name>.cached असे <name>.committed असे नाव बदलतो. जुने <name>.committed हटवले आहे.
5. वैकल्पिकरित्या, कॅशे 100% भरले असल्यास, ते स्क्रिप्टद्वारे पुन्हा तयार केले जाऊ शकते, अशा प्रकारे ते साफ केले जाऊ शकते. अर्ध्या-रिक्त कॅशेसह, लिहिताना सिस्टम अधिक जलद कार्य करते.
6. स्थलांतर थ्रेशोल्ड शून्यावर सेट करा: #lvchange --quiet --cachesettings "migration_threshold=0" cache/cachedata हे कॅशेला मुख्य माध्यमाशी समक्रमित होण्यापासून तात्पुरते प्रतिबंधित करेल.
7. कॅशेमध्ये बरेच बदल जमा होईपर्यंत आम्ही प्रतीक्षा करतो #lvs --rows --reportformat basic --quiet -ocache_dirty_blocks cache/cachedata | awk '{print $2}' किंवा टाइमर बंद होईल.
8. आम्ही पुन्हा पुनरावृत्ती करतो.

स्थलांतर थ्रेशोल्डमध्ये अडचणी का येतात...?गोष्ट अशी आहे की वास्तविक सराव मध्ये, "यादृच्छिक" रेकॉर्डिंग प्रत्यक्षात पूर्णपणे यादृच्छिक नसते. जर आम्ही 4 किलोबाइट आकाराच्या सेक्टरवर काहीतरी लिहिले, तर पुढील काही मिनिटांत त्याच किंवा शेजारच्या (+- 32K) क्षेत्रांपैकी एकावर रेकॉर्ड केले जाण्याची उच्च संभाव्यता आहे.

स्थलांतर थ्रेशोल्ड शून्यावर सेट करून, आम्ही SATA SSD वर लेखन सिंक्रोनाइझेशन पुढे ढकलतो आणि कॅशेमधील एका 64K ब्लॉकमध्ये अनेक बदल एकत्रित करतो. हे SATA SSD च्या संसाधनाची लक्षणीय बचत करते.

कोड कुठे आहे..?दुर्दैवाने, लेखक स्वत: ला बॅश स्क्रिप्ट्सच्या विकासामध्ये अपुरा सक्षम मानतो कारण तो 100% स्वयं-शिकलेला आहे आणि “गूगल”-चालित विकासाचा सराव करतो, म्हणून त्याचा असा विश्वास आहे की त्याच्या हातातून बाहेर पडलेला भयानक कोड कोणीही वापरू नये. इतर

मला वाटते की या क्षेत्रातील व्यावसायिक वर वर्णन केलेल्या सर्व तर्कांचे स्वतंत्रपणे चित्रण करण्यास सक्षम असतील, आवश्यक असल्यास, आणि, कदाचित, लेखकाने करण्याचा प्रयत्न केल्याप्रमाणे, सिस्टमड सेवा म्हणून ते सुंदरपणे डिझाइन देखील करू शकतील.

अशी साधी स्नॅपशॉट रोटेशन योजना आम्हाला केवळ SATA SSD वर एक स्नॅपशॉट पूर्णपणे सिंक्रोनाइझ करण्याची परवानगी देईल, परंतु thin_delta युटिलिटी वापरून, त्याच्या निर्मितीनंतर कोणते ब्लॉक बदलले आहेत हे शोधण्यासाठी आणि अशा प्रकारे नुकसान स्थानिकीकरण करण्यास अनुमती देईल. मुख्य खंड, पुनर्प्राप्ती मोठ्या प्रमाणात सुलभ करते.

libvirt/KVM मध्ये TRIM/DISCARD

कारण डेटा स्टोरेजचा वापर KVM रनिंग libvirt साठी केला जाईल, नंतर आमच्या VM ला फक्त मोकळी जागा घेण्यास शिकवणे चांगले नाही, तर आता जे आवश्यक नाही ते मोकळे करणे देखील चांगले आहे.

हे आभासी डिस्कवर TRIM/DISCARD समर्थनाचे अनुकरण करून केले जाते. हे करण्यासाठी, तुम्हाला कंट्रोलरचा प्रकार virtio-scsi मध्ये बदलणे आणि xml संपादित करणे आवश्यक आहे.

#virsh edit vmname
<disk type='block' device='disk'>
<driver name='qemu' type='raw' cache='writethrough' io='threads' discard='unmap'/>
<source dev='/dev/images/vmname'/>
<backingStore/>
<target dev='sda' bus='scsi'/>
<alias name='scsi0-0-0-0'/>
<address type='drive' controller='0' bus='0' target='0' unit='0'/>
</disk>

<controller type='scsi' index='0' model='virtio-scsi'>
<alias name='scsi0'/>
<address type='pci' domain='0x0000' bus='0x04' slot='0x00' function='0x0'/>
</controller>

अतिथी OS मधील अशा DISCARDs ला LVM द्वारे योग्यरित्या प्रक्रिया केली जाते, आणि ब्लॉक कॅशे आणि पातळ पूलमध्ये योग्यरित्या मुक्त केले जातात. आमच्या बाबतीत, पुढील स्नॅपशॉट हटवताना हे प्रामुख्याने विलंबित पद्धतीने होते.

BTRFS बॅकअप

सह तयार स्क्रिप्ट वापरा अत्यंत खबरदारी आणि स्वतःच्या जोखमीवर. लेखकाने ही संहिता स्वतः आणि केवळ स्वतःसाठी लिहिली आहे. मला खात्री आहे की बर्‍याच अनुभवी लिनक्स वापरकर्त्यांकडे समान साधने आहेत आणि इतर कोणाची कॉपी करण्याची आवश्यकता नाही.

चला बॅकअप डिव्हाइसवर व्हॉल्यूम तयार करूया:

#lvcreate -L 256G --name backup backup

चला ते BTRFS मध्ये स्वरूपित करूया:

#mkfs.btrfs /dev/backup/backup

चला माउंट पॉइंट तयार करू आणि फाइल सिस्टमचे रूट उपविभाग माउंट करू:

#mkdir /backup
#mkdir /backup/btrfs
#mkdir /backup/btrfs/root
#mkdir /backup/btrfs/back
#ln -s /boot /backup/btrfs
# cat >>/etc/fstab << EOF

/dev/mapper/root-root /backup/btrfs/root btrfs defaults,space_cache,noatime,nodiratime 0 2
/dev/mapper/backup-backup /backup/btrfs/back btrfs defaults,space_cache,noatime,nodiratime 0 2
EOF
#mount -a
#update-initramfs -u
#update-grub

चला बॅकअपसाठी निर्देशिका तयार करूया:

#mkdir /backup/btrfs/back/remote
#mkdir /backup/btrfs/back/remote/root
#mkdir /backup/btrfs/back/remote/boot

बॅकअप स्क्रिप्टसाठी निर्देशिका तयार करूया:

#mkdir /root/btrfs-backup

चला स्क्रिप्ट कॉपी करूया:

खूप भयानक बॅश कोड. आपल्या स्वत: च्या जोखमीवर वापरा. लेखकाला रागावणारी पत्रे लिहू नका...#cat >/root/btrfs-backup/btrfs-backup.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

SCRIPT_FILE="$(realpath $0)"
SCRIPT_DIR="$(dirname $SCRIPT_FILE)"
SCRIPT_NAME="$(basename -s .sh $SCRIPT_FILE)"

LOCK_FILE="/dev/shm/$SCRIPT_NAME.lock"
DATE_PREFIX='%Y-%m-%d'
DATE_FORMAT=$DATE_PREFIX'-%H-%M-%S'
DATE_REGEX='[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]'
BASE_SUFFIX=".@base"
PEND_SUFFIX=".@pend"
SNAP_SUFFIX=".@snap"
MOUNTS="/backup/btrfs/"
BACKUPS="/backup/btrfs/back/remote/"

function terminate ()
{
echo "$1" >&2
exit 1
}

function wait_lock()
{
flock 98
}

function wait_lock_or_terminate()
{
echo "Wating for lock..."
wait_lock || terminate "Failed to get lock. Exiting..."
echo "Got lock..."
}

function suffix()
{
FORMATTED_DATE=$(date +"$DATE_FORMAT")
echo "$SNAP_SUFFIX.$FORMATTED_DATE"
}

function filter()
{
FORMATTED_DATE=$(date --date="$1" +"$DATE_PREFIX")
echo "$SNAP_SUFFIX.$FORMATTED_DATE"
}

function backup()
{
SOURCE_PATH="$MOUNTS$1"
TARGET_PATH="$BACKUPS$1"
SOURCE_BASE_PATH="$MOUNTS$1$BASE_SUFFIX"
TARGET_BASE_PATH="$BACKUPS$1$BASE_SUFFIX"
TARGET_BASE_DIR="$(dirname $TARGET_BASE_PATH)"
SOURCE_PEND_PATH="$MOUNTS$1$PEND_SUFFIX"
TARGET_PEND_PATH="$BACKUPS$1$PEND_SUFFIX"
if [ -d "$SOURCE_BASE_PATH" ] then
echo "$SOURCE_BASE_PATH found"
else
echo "$SOURCE_BASE_PATH File not found creating snapshot of $SOURCE_PATH to $SOURCE_BASE_PATH"
btrfs subvolume snapshot -r $SOURCE_PATH $SOURCE_BASE_PATH
sync
if [ -d "$TARGET_BASE_PATH" ] then
echo "$TARGET_BASE_PATH found out of sync with source... removing..."
btrfs subvolume delete -c $TARGET_BASE_PATH
sync
fi
fi
if [ -d "$TARGET_BASE_PATH" ] then
echo "$TARGET_BASE_PATH found"
else
echo "$TARGET_BASE_PATH not found. Synching to $TARGET_BASE_DIR"
btrfs send $SOURCE_BASE_PATH | btrfs receive $TARGET_BASE_DIR
sync
fi
if [ -d "$SOURCE_PEND_PATH" ] then
echo "$SOURCE_PEND_PATH found removing..."
btrfs subvolume delete -c $SOURCE_PEND_PATH
sync
fi
btrfs subvolume snapshot -r $SOURCE_PATH $SOURCE_PEND_PATH
sync
if [ -d "$TARGET_PEND_PATH" ] then
echo "$TARGET_PEND_PATH found removing..."
btrfs subvolume delete -c $TARGET_PEND_PATH
sync
fi
echo "Sending $SOURCE_PEND_PATH to $TARGET_PEND_PATH"
btrfs send -p $SOURCE_BASE_PATH $SOURCE_PEND_PATH | btrfs receive $TARGET_BASE_DIR
sync
TARGET_DATE_SUFFIX=$(suffix)
btrfs subvolume snapshot -r $TARGET_PEND_PATH "$TARGET_PATH$TARGET_DATE_SUFFIX"
sync
btrfs subvolume delete -c $SOURCE_BASE_PATH
sync
btrfs subvolume delete -c $TARGET_BASE_PATH
sync
mv $SOURCE_PEND_PATH $SOURCE_BASE_PATH
mv $TARGET_PEND_PATH $TARGET_BASE_PATH
sync
}

function list()
{
LIST_TARGET_BASE_PATH="$BACKUPS$1$BASE_SUFFIX"
LIST_TARGET_BASE_DIR="$(dirname $LIST_TARGET_BASE_PATH)"
LIST_TARGET_BASE_NAME="$(basename -s .$BASE_SUFFIX $LIST_TARGET_BASE_PATH)"
find "$LIST_TARGET_BASE_DIR" -maxdepth 1 -mindepth 1 -type d -printf "%fn" | grep "${LIST_TARGET_BASE_NAME/$BASE_SUFFIX/$SNAP_SUFFIX}.$DATE_REGEX"
}

function remove()
{
REMOVE_TARGET_BASE_PATH="$BACKUPS$1$BASE_SUFFIX"
REMOVE_TARGET_BASE_DIR="$(dirname $REMOVE_TARGET_BASE_PATH)"
btrfs subvolume delete -c $REMOVE_TARGET_BASE_DIR/$2
sync
}

function removeall()
{
DATE_OFFSET="$2"
FILTER="$(filter "$DATE_OFFSET")"
while read -r SNAPSHOT ; do
remove "$1" "$SNAPSHOT"
done < <(list "$1" | grep "$FILTER")

}

(
COMMAND="$1"
shift

case "$COMMAND" in
"--help")
echo "Help"
;;
"suffix")
suffix
;;
"filter")
filter "$1"
;;
"backup")
wait_lock_or_terminate
backup "$1"
;;
"list")
list "$1"
;;
"remove")
wait_lock_or_terminate
remove "$1" "$2"
;;
"removeall")
wait_lock_or_terminate
removeall "$1" "$2"
;;
*)
echo "None.."
;;
esac
) 98>$LOCK_FILE

EOF


हे तरी काय करते..?BTRFS स्नॅपशॉट तयार करण्यासाठी आणि BTRFS पाठवा/मिळवण्याचा वापर करून दुसर्‍या FS वर कॉपी करण्यासाठी सोप्या आदेशांचा संच आहे.

पहिले प्रक्षेपण तुलनेने लांब असू शकते, कारण... सुरुवातीला, सर्व डेटा कॉपी केला जाईल. पुढील प्रक्षेपण खूप जलद होतील, कारण... फक्त बदल कॉपी केले जातील.

दुसरी स्क्रिप्ट जी आम्ही क्रॉनमध्ये ठेवू:

आणखी काही बॅश कोड#cat >/root/btrfs-backup/cron-daily.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

SCRIPT_FILE="$(realpath $0)"
SCRIPT_DIR="$(dirname $SCRIPT_FILE)"
SCRIPT_NAME="$(basename -s .sh $SCRIPT_FILE)"

BACKUP_SCRIPT="$SCRIPT_DIR/btrfs-backup.sh"
RETENTION="-60 day"
$BACKUP_SCRIPT backup root/@
$BACKUP_SCRIPT removeall root/@ "$RETENTION"
$BACKUP_SCRIPT backup root/@home
$BACKUP_SCRIPT removeall root/@home "$RETENTION"
$BACKUP_SCRIPT backup boot/
$BACKUP_SCRIPT removeall boot/ "$RETENTION"
EOF


ते काय करते..?बॅकअप FS वर सूचीबद्ध BTRFS व्हॉल्यूमचे वाढीव स्नॅपशॉट तयार आणि समक्रमित करते. यानंतर, ते 60 दिवसांपूर्वी तयार केलेले सर्व चित्र हटवते. लाँच केल्यानंतर, सूचीबद्ध खंडांचे दिनांकित स्नॅपशॉट्स /backup/btrfs/back/remote/ subdirectories मध्ये दिसून येतील.

चला कोडच्या अंमलबजावणीचे अधिकार देऊ:

#chmod +x /root/btrfs-backup/cron-daily.sh
#chmod +x /root/btrfs-backup/btrfs-backup.sh

चला ते तपासू आणि क्रॉनमध्ये ठेवू:

#/usr/bin/nice -n 19 /usr/bin/ionice -c 3 /root/btrfs-backup/cron-daily.sh 2>&1 | /usr/bin/logger -t btrfs-backup
#cat /var/log/syslog | grep btrfs-backup
#crontab -e
0 2 * * * /usr/bin/nice -n 19 /usr/bin/ionice -c 3 /root/btrfs-backup/cron-daily.sh 2>&1 | /usr/bin/logger -t btrfs-backup


LVM पातळ बॅकअप

चला बॅकअप डिव्हाइसवर एक पातळ पूल तयार करूया:

#lvcreate -L 274877906944B --poolmetadataspare y --poolmetadatasize 4294967296B --chunksize 64k -Z y -T backup/thin-pool

चला ddrescue स्थापित करूया, कारण... स्क्रिप्ट हे साधन वापरतील:

#apt-get install gddrescue

चला स्क्रिप्टसाठी निर्देशिका तयार करूया:

#mkdir /root/lvm-thin-backup

चला स्क्रिप्ट कॉपी करूया:

आत खूप धमाल...#cat >/root/lvm-thin-backup/lvm-thin-backup.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

SCRIPT_FILE="$(realpath $0)"
SCRIPT_DIR="$(dirname $SCRIPT_FILE)"
SCRIPT_NAME="$(basename -s .sh $SCRIPT_FILE)"

LOCK_FILE="/dev/shm/$SCRIPT_NAME.lock"
DATE_PREFIX='%Y-%m-%d'
DATE_FORMAT=$DATE_PREFIX'-%H-%M-%S'
DATE_REGEX='[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]'
BASE_SUFFIX=".base"
PEND_SUFFIX=".pend"
SNAP_SUFFIX=".snap"
BACKUPS="backup"
BACKUPS_POOL="thin-pool"

export LVM_SUPPRESS_FD_WARNINGS=1

function terminate ()
{
echo "$1" >&2
exit 1
}

function wait_lock()
{
flock 98
}

function wait_lock_or_terminate()
{
echo "Wating for lock..."
wait_lock || terminate "Failed to get lock. Exiting..."
echo "Got lock..."
}

function suffix()
{
FORMATTED_DATE=$(date +"$DATE_FORMAT")
echo "$SNAP_SUFFIX.$FORMATTED_DATE"
}

function filter()
{
FORMATTED_DATE=$(date --date="$1" +"$DATE_PREFIX")
echo "$SNAP_SUFFIX.$FORMATTED_DATE"
}

function read_thin_id {
lvs --rows --reportformat basic --quiet -othin_id "$1/$2" | awk '{print $2}'
}

function read_pool_lv {
lvs --rows --reportformat basic --quiet -opool_lv "$1/$2" | awk '{print $2}'
}

function read_lv_dm_path {
lvs --rows --reportformat basic --quiet -olv_dm_path "$1/$2" | awk '{print $2}'
}

function read_lv_active {
lvs --rows --reportformat basic --quiet -olv_active "$1/$2" | awk '{print $2}'
}

function read_lv_chunk_size {
lvs --rows --reportformat basic --quiet --units b --nosuffix -ochunk_size "$1/$2" | awk '{print $2}'
}

function read_lv_size {
lvs --rows --reportformat basic --quiet --units b --nosuffix -olv_size "$1/$2" | awk '{print $2}'
}

function activate_volume {
lvchange -ay -Ky "$1/$2"
}

function deactivate_volume {
lvchange -an "$1/$2"
}

function read_thin_metadata_snap {
dmsetup status "$1" | awk '{print $7}'
}

function thindiff()
{
DIFF_VG="$1"
DIFF_SOURCE="$2"
DIFF_TARGET="$3"
DIFF_SOURCE_POOL=$(read_pool_lv $DIFF_VG $DIFF_SOURCE)
DIFF_TARGET_POOL=$(read_pool_lv $DIFF_VG $DIFF_TARGET)

if [ "$DIFF_SOURCE_POOL" == "" ] then
(>&2 echo "Source LV is not thin.")
exit 1
fi

if [ "$DIFF_TARGET_POOL" == "" ] then
(>&2 echo "Target LV is not thin.")
exit 1
fi

if [ "$DIFF_SOURCE_POOL" != "$DIFF_TARGET_POOL" ] then
(>&2 echo "Source and target LVs belong to different thin pools.")
exit 1
fi

DIFF_POOL_PATH=$(read_lv_dm_path $DIFF_VG $DIFF_SOURCE_POOL)
DIFF_SOURCE_ID=$(read_thin_id $DIFF_VG $DIFF_SOURCE)
DIFF_TARGET_ID=$(read_thin_id $DIFF_VG $DIFF_TARGET)
DIFF_POOL_PATH_TPOOL="$DIFF_POOL_PATH-tpool"
DIFF_POOL_PATH_TMETA="$DIFF_POOL_PATH"_tmeta
DIFF_POOL_METADATA_SNAP=$(read_thin_metadata_snap $DIFF_POOL_PATH_TPOOL)

if [ "$DIFF_POOL_METADATA_SNAP" != "-" ] then
(>&2 echo "Thin pool metadata snapshot already exist. Assuming stale one. Will release metadata snapshot in 5 seconds.")
sleep 5
dmsetup message $DIFF_POOL_PATH_TPOOL 0 release_metadata_snap
fi

dmsetup message $DIFF_POOL_PATH_TPOOL 0 reserve_metadata_snap
DIFF_POOL_METADATA_SNAP=$(read_thin_metadata_snap $DIFF_POOL_PATH_TPOOL)

if [ "$DIFF_POOL_METADATA_SNAP" == "-" ] then
(>&2 echo "Failed to create thin pool metadata snapshot.")
exit 1
fi

#We keep output in variable because metadata snapshot need to be released early.
DIFF_DATA=$(thin_delta -m$DIFF_POOL_METADATA_SNAP --snap1 $DIFF_SOURCE_ID --snap2 $DIFF_TARGET_ID $DIFF_POOL_PATH_TMETA)

dmsetup message $DIFF_POOL_PATH_TPOOL 0 release_metadata_snap

echo $"$DIFF_DATA" | grep -E 'different|left_only|right_only' | sed 's/</"/g' | sed 's/ /"/g' | awk -F'"' '{print $6 "t" $8 "t" $11}' | sed 's/different/copy/g' | sed 's/left_only/copy/g' | sed 's/right_only/discard/g'

}

function thinsync()
{
SYNC_VG="$1"
SYNC_PEND="$2"
SYNC_BASE="$3"
SYNC_TARGET="$4"
SYNC_PEND_POOL=$(read_pool_lv $SYNC_VG $SYNC_PEND)
SYNC_BLOCK_SIZE=$(read_lv_chunk_size $SYNC_VG $SYNC_PEND_POOL)
SYNC_PEND_PATH=$(read_lv_dm_path $SYNC_VG $SYNC_PEND)

activate_volume $SYNC_VG $SYNC_PEND

while read -r SYNC_ACTION SYNC_OFFSET SYNC_LENGTH ; do
SYNC_OFFSET_BYTES=$((SYNC_OFFSET * SYNC_BLOCK_SIZE))
SYNC_LENGTH_BYTES=$((SYNC_LENGTH * SYNC_BLOCK_SIZE))
if [ "$SYNC_ACTION" == "copy" ] then
ddrescue --quiet --force --input-position=$SYNC_OFFSET_BYTES --output-position=$SYNC_OFFSET_BYTES --size=$SYNC_LENGTH_BYTES "$SYNC_PEND_PATH" "$SYNC_TARGET"
fi

if [ "$SYNC_ACTION" == "discard" ] then
blkdiscard -o $SYNC_OFFSET_BYTES -l $SYNC_LENGTH_BYTES "$SYNC_TARGET"
fi
done < <(thindiff "$SYNC_VG" "$SYNC_PEND" "$SYNC_BASE")
}

function discard_volume()
{
DISCARD_VG="$1"
DISCARD_LV="$2"
DISCARD_LV_PATH=$(read_lv_dm_path "$DISCARD_VG" "$DISCARD_LV")
if [ "$DISCARD_LV_PATH" != "" ] then
echo "$DISCARD_LV_PATH found"
else
echo "$DISCARD_LV not found in $DISCARD_VG"
exit 1
fi
DISCARD_LV_POOL=$(read_pool_lv $DISCARD_VG $DISCARD_LV)
DISCARD_LV_SIZE=$(read_lv_size "$DISCARD_VG" "$DISCARD_LV")
lvremove -y --quiet "$DISCARD_LV_PATH" || exit 1
lvcreate --thin-pool "$DISCARD_LV_POOL" -V "$DISCARD_LV_SIZE"B --name "$DISCARD_LV" "$DISCARD_VG" || exit 1
}

function backup()
{
SOURCE_VG="$1"
SOURCE_LV="$2"
TARGET_VG="$BACKUPS"
TARGET_LV="$SOURCE_VG-$SOURCE_LV"
SOURCE_BASE_LV="$SOURCE_LV$BASE_SUFFIX"
TARGET_BASE_LV="$TARGET_LV$BASE_SUFFIX"
SOURCE_PEND_LV="$SOURCE_LV$PEND_SUFFIX"
TARGET_PEND_LV="$TARGET_LV$PEND_SUFFIX"
SOURCE_BASE_LV_PATH=$(read_lv_dm_path "$SOURCE_VG" "$SOURCE_BASE_LV")
SOURCE_PEND_LV_PATH=$(read_lv_dm_path "$SOURCE_VG" "$SOURCE_PEND_LV")
TARGET_BASE_LV_PATH=$(read_lv_dm_path "$TARGET_VG" "$TARGET_BASE_LV")
TARGET_PEND_LV_PATH=$(read_lv_dm_path "$TARGET_VG" "$TARGET_PEND_LV")

if [ "$SOURCE_BASE_LV_PATH" != "" ] then
echo "$SOURCE_BASE_LV_PATH found"
else
echo "Source base not found creating snapshot of $SOURCE_VG/$SOURCE_LV to $SOURCE_VG/$SOURCE_BASE_LV"
lvcreate --quiet --snapshot --name "$SOURCE_BASE_LV" "$SOURCE_VG/$SOURCE_LV" || exit 1
SOURCE_BASE_LV_PATH=$(read_lv_dm_path "$SOURCE_VG" "$SOURCE_BASE_LV")
activate_volume "$SOURCE_VG" "$SOURCE_BASE_LV"
echo "Discarding $SOURCE_BASE_LV_PATH as we need to bootstrap."
SOURCE_BASE_POOL=$(read_pool_lv $SOURCE_VG $SOURCE_BASE_LV)
SOURCE_BASE_CHUNK_SIZE=$(read_lv_chunk_size $SOURCE_VG $SOURCE_BASE_POOL)
discard_volume "$SOURCE_VG" "$SOURCE_BASE_LV"
sync
if [ "$TARGET_BASE_LV_PATH" != "" ] then
echo "$TARGET_BASE_LV_PATH found out of sync with source... removing..."
lvremove -y --quiet $TARGET_BASE_LV_PATH || exit 1
TARGET_BASE_LV_PATH=$(read_lv_dm_path "$TARGET_VG" "$TARGET_BASE_LV")
sync
fi
fi
SOURCE_BASE_SIZE=$(read_lv_size "$SOURCE_VG" "$SOURCE_BASE_LV")
if [ "$TARGET_BASE_LV_PATH" != "" ] then
echo "$TARGET_BASE_LV_PATH found"
else
echo "$TARGET_VG/$TARGET_LV not found. Creating empty volume."
lvcreate --thin-pool "$BACKUPS_POOL" -V "$SOURCE_BASE_SIZE"B --name "$TARGET_BASE_LV" "$TARGET_VG" || exit 1
echo "Have to rebootstrap. Discarding source at $SOURCE_BASE_LV_PATH"
activate_volume "$SOURCE_VG" "$SOURCE_BASE_LV"
SOURCE_BASE_POOL=$(read_pool_lv $SOURCE_VG $SOURCE_BASE_LV)
SOURCE_BASE_CHUNK_SIZE=$(read_lv_chunk_size $SOURCE_VG $SOURCE_BASE_POOL)
discard_volume "$SOURCE_VG" "$SOURCE_BASE_LV"
TARGET_BASE_POOL=$(read_pool_lv $TARGET_VG $TARGET_BASE_LV)
TARGET_BASE_CHUNK_SIZE=$(read_lv_chunk_size $TARGET_VG $TARGET_BASE_POOL)
TARGET_BASE_LV_PATH=$(read_lv_dm_path "$TARGET_VG" "$TARGET_BASE_LV")
echo "Discarding target at $TARGET_BASE_LV_PATH"
discard_volume "$TARGET_VG" "$TARGET_BASE_LV"
sync
fi
if [ "$SOURCE_PEND_LV_PATH" != "" ] then
echo "$SOURCE_PEND_LV_PATH found removing..."
lvremove -y --quiet "$SOURCE_PEND_LV_PATH" || exit 1
sync
fi
lvcreate --quiet --snapshot --name "$SOURCE_PEND_LV" "$SOURCE_VG/$SOURCE_LV" || exit 1
SOURCE_PEND_LV_PATH=$(read_lv_dm_path "$SOURCE_VG" "$SOURCE_PEND_LV")
sync
if [ "$TARGET_PEND_LV_PATH" != "" ] then
echo "$TARGET_PEND_LV_PATH found removing..."
lvremove -y --quiet $TARGET_PEND_LV_PATH
sync
fi
lvcreate --quiet --snapshot --name "$TARGET_PEND_LV" "$TARGET_VG/$TARGET_BASE_LV" || exit 1
TARGET_PEND_LV_PATH=$(read_lv_dm_path "$TARGET_VG" "$TARGET_PEND_LV")
SOURCE_PEND_LV_SIZE=$(read_lv_size "$SOURCE_VG" "$SOURCE_PEND_LV")
lvresize -L "$SOURCE_PEND_LV_SIZE"B "$TARGET_PEND_LV_PATH"
activate_volume "$TARGET_VG" "$TARGET_PEND_LV"
echo "Synching $SOURCE_PEND_LV_PATH to $TARGET_PEND_LV_PATH"
thinsync "$SOURCE_VG" "$SOURCE_PEND_LV" "$SOURCE_BASE_LV" "$TARGET_PEND_LV_PATH" || exit 1
sync

TARGET_DATE_SUFFIX=$(suffix)
lvcreate --quiet --snapshot --name "$TARGET_LV$TARGET_DATE_SUFFIX" "$TARGET_VG/$TARGET_PEND_LV" || exit 1
sync
lvremove --quiet -y "$SOURCE_BASE_LV_PATH" || exit 1
sync
lvremove --quiet -y "$TARGET_BASE_LV_PATH" || exit 1
sync
lvrename -y "$SOURCE_VG/$SOURCE_PEND_LV" "$SOURCE_BASE_LV" || exit 1
lvrename -y "$TARGET_VG/$TARGET_PEND_LV" "$TARGET_BASE_LV" || exit 1
sync
deactivate_volume "$TARGET_VG" "$TARGET_BASE_LV"
deactivate_volume "$SOURCE_VG" "$SOURCE_BASE_LV"
}

function verify()
{
SOURCE_VG="$1"
SOURCE_LV="$2"
TARGET_VG="$BACKUPS"
TARGET_LV="$SOURCE_VG-$SOURCE_LV"
SOURCE_BASE_LV="$SOURCE_LV$BASE_SUFFIX"
TARGET_BASE_LV="$TARGET_LV$BASE_SUFFIX"
TARGET_BASE_LV_PATH=$(read_lv_dm_path "$TARGET_VG" "$TARGET_BASE_LV")
SOURCE_BASE_LV_PATH=$(read_lv_dm_path "$SOURCE_VG" "$SOURCE_BASE_LV")

if [ "$SOURCE_BASE_LV_PATH" != "" ] then
echo "$SOURCE_BASE_LV_PATH found"
else
echo "$SOURCE_BASE_LV_PATH not found"
exit 1
fi
if [ "$TARGET_BASE_LV_PATH" != "" ] then
echo "$TARGET_BASE_LV_PATH found"
else
echo "$TARGET_BASE_LV_PATH not found"
exit 1
fi
activate_volume "$TARGET_VG" "$TARGET_BASE_LV"
activate_volume "$SOURCE_VG" "$SOURCE_BASE_LV"
echo Comparing "$SOURCE_BASE_LV_PATH" with "$TARGET_BASE_LV_PATH"
cmp "$SOURCE_BASE_LV_PATH" "$TARGET_BASE_LV_PATH"
echo Done...
deactivate_volume "$TARGET_VG" "$TARGET_BASE_LV"
deactivate_volume "$SOURCE_VG" "$SOURCE_BASE_LV"
}

function resync()
{
SOURCE_VG="$1"
SOURCE_LV="$2"
TARGET_VG="$BACKUPS"
TARGET_LV="$SOURCE_VG-$SOURCE_LV"
SOURCE_BASE_LV="$SOURCE_LV$BASE_SUFFIX"
TARGET_BASE_LV="$TARGET_LV$BASE_SUFFIX"
TARGET_BASE_LV_PATH=$(read_lv_dm_path "$TARGET_VG" "$TARGET_BASE_LV")
SOURCE_BASE_LV_PATH=$(read_lv_dm_path "$SOURCE_VG" "$SOURCE_BASE_LV")

if [ "$SOURCE_BASE_LV_PATH" != "" ] then
echo "$SOURCE_BASE_LV_PATH found"
else
echo "$SOURCE_BASE_LV_PATH not found"
exit 1
fi
if [ "$TARGET_BASE_LV_PATH" != "" ] then
echo "$TARGET_BASE_LV_PATH found"
else
echo "$TARGET_BASE_LV_PATH not found"
exit 1
fi
activate_volume "$TARGET_VG" "$TARGET_BASE_LV"
activate_volume "$SOURCE_VG" "$SOURCE_BASE_LV"
SOURCE_BASE_POOL=$(read_pool_lv $SOURCE_VG $SOURCE_BASE_LV)
SYNC_BLOCK_SIZE=$(read_lv_chunk_size $SOURCE_VG $SOURCE_BASE_POOL)

echo Syncronizing "$SOURCE_BASE_LV_PATH" to "$TARGET_BASE_LV_PATH"

CMP_OFFSET=0
while [[ "$CMP_OFFSET" != "" ]] ; do
CMP_MISMATCH=$(cmp -i "$CMP_OFFSET" "$SOURCE_BASE_LV_PATH" "$TARGET_BASE_LV_PATH" | grep differ | awk '{print $5}' | sed 's/,//g' )
if [[ "$CMP_MISMATCH" != "" ]] ; then
CMP_OFFSET=$(( CMP_MISMATCH + CMP_OFFSET ))
SYNC_OFFSET_BYTES=$(( ( CMP_OFFSET / SYNC_BLOCK_SIZE ) * SYNC_BLOCK_SIZE ))
SYNC_LENGTH_BYTES=$(( SYNC_BLOCK_SIZE ))
echo "Synching $SYNC_LENGTH_BYTES bytes at $SYNC_OFFSET_BYTES from $SOURCE_BASE_LV_PATH to $TARGET_BASE_LV_PATH"
ddrescue --quiet --force --input-position=$SYNC_OFFSET_BYTES --output-position=$SYNC_OFFSET_BYTES --size=$SYNC_LENGTH_BYTES "$SOURCE_BASE_LV_PATH" "$TARGET_BASE_LV_PATH"
else
CMP_OFFSET=""
fi
done
echo Done...
deactivate_volume "$TARGET_VG" "$TARGET_BASE_LV"
deactivate_volume "$SOURCE_VG" "$SOURCE_BASE_LV"
}

function list()
{
LIST_SOURCE_VG="$1"
LIST_SOURCE_LV="$2"
LIST_TARGET_VG="$BACKUPS"
LIST_TARGET_LV="$LIST_SOURCE_VG-$LIST_SOURCE_LV"
LIST_TARGET_BASE_LV="$LIST_TARGET_LV$SNAP_SUFFIX"
lvs -olv_name | grep "$LIST_TARGET_BASE_LV.$DATE_REGEX"
}

function remove()
{
REMOVE_TARGET_VG="$BACKUPS"
REMOVE_TARGET_LV="$1"
lvremove -y "$REMOVE_TARGET_VG/$REMOVE_TARGET_LV"
sync
}

function removeall()
{
DATE_OFFSET="$3"
FILTER="$(filter "$DATE_OFFSET")"
while read -r SNAPSHOT ; do
remove "$SNAPSHOT"
done < <(list "$1" "$2" | grep "$FILTER")

}

(
COMMAND="$1"
shift

case "$COMMAND" in
"--help")
echo "Help"
;;
"suffix")
suffix
;;
"filter")
filter "$1"
;;
"backup")
wait_lock_or_terminate
backup "$1" "$2"
;;
"list")
list "$1" "$2"
;;
"thindiff")
thindiff "$1" "$2" "$3"
;;
"thinsync")
thinsync "$1" "$2" "$3" "$4"
;;
"verify")
wait_lock_or_terminate
verify "$1" "$2"
;;
"resync")
wait_lock_or_terminate
resync "$1" "$2"
;;
"remove")
wait_lock_or_terminate
remove "$1"
;;
"removeall")
wait_lock_or_terminate
removeall "$1" "$2" "$3"
;;
*)
echo "None.."
;;
esac
) 98>$LOCK_FILE

EOF


ते काय करते...?पातळ स्नॅपशॉट्स हाताळण्यासाठी आणि ddrescue आणि blkdiscard वापरून thin_delta द्वारे प्राप्त झालेल्या दोन पातळ स्नॅपशॉटमधील फरक दुसर्‍या ब्लॉक डिव्हाइसवर सिंक्रोनाइझ करण्यासाठी आदेशांचा एक संच समाविष्ट आहे.

दुसरी स्क्रिप्ट जी आम्ही क्रॉनमध्ये ठेवू:

जरा जास्त बाश#cat >/root/lvm-thin-backup/cron-daily.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

SCRIPT_FILE="$(realpath $0)"
SCRIPT_DIR="$(dirname $SCRIPT_FILE)"
SCRIPT_NAME="$(basename -s .sh $SCRIPT_FILE)"

BACKUP_SCRIPT="$SCRIPT_DIR/lvm-thin-backup.sh"
RETENTION="-60 days"

$BACKUP_SCRIPT backup images linux-dev
$BACKUP_SCRIPT backup images win8
$BACKUP_SCRIPT backup images win8-data
#etc

$BACKUP_SCRIPT removeall images linux-dev "$RETENTION"
$BACKUP_SCRIPT removeall images win8 "$RETENTION"
$BACKUP_SCRIPT removeall images win8-data "$RETENTION"
#etc

EOF


ते काय करते...?सूचीबद्ध पातळ व्हॉल्यूमचे बॅकअप तयार आणि सिंक्रोनाइझ करण्यासाठी मागील स्क्रिप्ट वापरते. स्क्रिप्ट सूचीबद्ध खंडांचे निष्क्रिय स्नॅपशॉट सोडेल, जे शेवटच्या सिंक्रोनाइझेशनपासून बदलांचा मागोवा घेण्यासाठी आवश्यक आहे.

ही स्क्रिप्ट संपादित करणे आवश्यक आहे, ज्याच्या बॅकअप प्रती बनवल्या पाहिजेत अशा पातळ खंडांची सूची निर्दिष्ट करते. दिलेली नावे केवळ स्पष्टीकरणासाठी आहेत. तुमची इच्छा असल्यास, तुम्ही एक स्क्रिप्ट लिहू शकता जी सर्व खंड समक्रमित करेल.

चला अधिकार देऊ:

#chmod +x /root/lvm-thin-backup/cron-daily.sh
#chmod +x /root/lvm-thin-backup/lvm-thin-backup.sh

चला ते तपासू आणि क्रॉनमध्ये ठेवू:

#/usr/bin/nice -n 19 /usr/bin/ionice -c 3 /root/lvm-thin-backup/cron-daily.sh 2>&1 | /usr/bin/logger -t lvm-thin-backup
#cat /var/log/syslog | grep lvm-thin-backup
#crontab -e
0 3 * * * /usr/bin/nice -n 19 /usr/bin/ionice -c 3 /root/lvm-thin-backup/cron-daily.sh 2>&1 | /usr/bin/logger -t lvm-thin-backup

पहिले प्रक्षेपण लांबलचक असेल, कारण... सर्व वापरलेली जागा कॉपी करून पातळ खंड पूर्णपणे सिंक्रोनाइझ केले जातील. LVM पातळ मेटाडेटाबद्दल धन्यवाद, आम्हाला माहित आहे की कोणते ब्लॉक्स प्रत्यक्षात वापरात आहेत, त्यामुळे फक्त प्रत्यक्षात वापरलेले पातळ व्हॉल्यूम ब्लॉक कॉपी केले जातील.

त्यानंतरच्या धावांमुळे LVM पातळ मेटाडेटाद्वारे ट्रॅकिंग बदलल्याबद्दल धन्यवाद वाढत्या प्रमाणात डेटा कॉपी केला जाईल.

काय झाले ते पाहूया:

#time /root/btrfs-backup/cron-daily.sh
real 0m2,967s
user 0m0,225s
sys 0m0,353s

#time /root/lvm-thin-backup/cron-daily.sh
real 1m2,710s
user 0m12,721s
sys 0m6,671s

#ls -al /backup/btrfs/back/remote/*
/backup/btrfs/back/remote/boot:
total 0
drwxr-xr-x 1 root root 1260 мар 26 09:11 .
drwxr-xr-x 1 root root 16 мар 6 09:30 ..
drwxr-xr-x 1 root root 322 мар 26 02:00 .@base
drwxr-xr-x 1 root root 516 мар 6 09:39 [email protected]
drwxr-xr-x 1 root root 516 мар 6 09:39 [email protected]
...
/backup/btrfs/back/remote/root:
total 0
drwxr-xr-x 1 root root 2820 мар 26 09:11 .
drwxr-xr-x 1 root root 16 мар 6 09:30 ..
drwxr-xr-x 1 root root 240 мар 26 09:11 @.@base
drwxr-xr-x 1 root root 22 мар 26 09:11 @home.@base
drwxr-xr-x 1 root root 22 мар 6 09:39 @[email protected]
drwxr-xr-x 1 root root 22 мар 6 09:39 @[email protected]
...
drwxr-xr-x 1 root root 240 мар 6 09:39 @[email protected]
drwxr-xr-x 1 root root 240 мар 6 09:39 @[email protected]
...

#lvs -olv_name,lv_size images && lvs -olv_name,lv_size backup
LV LSize
linux-dev 128,00g
linux-dev.base 128,00g
thin-pool 1,38t
win8 128,00g
win8-data 2,00t
win8-data.base 2,00t
win8.base 128,00g
LV LSize
backup 256,00g
images-linux-dev.base 128,00g
images-linux-dev.snap.2020-03-08-10-09-11 128,00g
images-linux-dev.snap.2020-03-08-10-09-25 128,00g
...
images-win8-data.base 2,00t
images-win8-data.snap.2020-03-16-14-11-55 2,00t
images-win8-data.snap.2020-03-16-14-19-50 2,00t
...
images-win8.base 128,00g
images-win8.snap.2020-03-17-04-51-46 128,00g
images-win8.snap.2020-03-18-03-02-49 128,00g
...
thin-pool <2,09t


याचा घरट्यातल्या बाहुल्यांशी काय संबंध?

बहुधा, LVM LV लॉजिकल व्हॉल्यूम्स इतर VG साठी LVM PV फिजिकल व्हॉल्यूम असू शकतात. LVM आवर्ती असू शकते, जसे की नेस्टिंग डॉल. हे LVM ला अत्यंत लवचिकता देते.

PS

पुढील लेखात, आम्ही होम डेस्कटॉप, होम इंटरनेट आणि P2P नेटवर्क वापरून अनेक खंडांवर रिडंडंसीसह भू-वितरित स्टोरेज/व्हीएम क्लस्टर तयार करण्यासाठी आधार म्हणून अनेक समान मोबाइल स्टोरेज सिस्टम/KVM वापरण्याचा प्रयत्न करू.

स्त्रोत: www.habr.com