எல்விஎம் மற்றும் மெட்ரியோஷ்கா இடையே பொதுவானது என்ன?

நாள் நேரம்.
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 இல் நிறுவுகிறது.
• எல்விஎம் கேச் மற்றும் எல்விஎம் மெல்லியதைப் பயன்படுத்துதல்.
• BTRFS ஸ்னாப்ஷாட்களைப் பயன்படுத்துதல் மற்றும் காப்புப்பிரதிக்கு அனுப்புதல்/பெறுதல்.
• BTRFS பாணி காப்புப்பிரதிகளுக்கு LVM மெல்லிய ஸ்னாப்ஷாட்கள் மற்றும் thin_delta ஐப் பயன்படுத்துதல்.

நீங்கள் ஆர்வமாக இருந்தால், பூனையைப் பார்க்கவும்.

விண்ணப்ப படிவம்

இந்தக் கட்டுரையிலிருந்து பொருட்கள்/எடுத்துக்காட்டுகள்/குறியீடு/உதவிக்குறிப்புகள்/தரவைப் பயன்படுத்துவதால் அல்லது பயன்படுத்தாமல் இருப்பதன் விளைவுகளுக்கு ஆசிரியர் எந்தப் பொறுப்பையும் ஏற்கவில்லை. இந்த விஷயத்தைப் படிப்பதன் மூலம் அல்லது எந்த வகையிலும் பயன்படுத்துவதன் மூலம், இந்த செயல்களின் அனைத்து விளைவுகளுக்கும் நீங்கள் பொறுப்பேற்கிறீர்கள். சாத்தியமான விளைவுகள் பின்வருமாறு:

• மிருதுவாக வறுத்த NVMe SSDகள்.
• ரெக்கார்டிங் ஆதாரம் மற்றும் SSD டிரைவ்களின் தோல்வி முற்றிலும் பயன்படுத்தப்பட்டது.
• காப்பு பிரதிகள் உட்பட அனைத்து டிரைவ்களிலும் உள்ள அனைத்து தரவையும் முழுமையாக இழக்கும்.
• தவறான கணினி வன்பொருள்.
• வீணான நேரம், நரம்புகள் மற்றும் பணம்.
• மேலே பட்டியலிடப்படாத பிற விளைவுகள்.

இரும்பு

கிடைக்கக்கூடியவை:

2013 ஆம் ஆண்டு முதல் Z87 சிப்செட் கொண்ட மதர்போர்டு, Intel Core i7 / Haswell உடன் முழுமையானது.

• செயலி 4 கோர்கள், 8 நூல்கள்
• 32 ஜிபி டிடிஆர்3 ரேம்
• 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/டிஸ்கார்டு பொதுவாக வட்டுகளில் வேலை செய்கிறது, ஏனெனில்... RAID ஃபார்ம்வேரில் இந்த கட்டளைகள் ஆதரிக்கப்படுவதில்லை, மேலும் HBA பொதுவாக, பஸ்ஸில் என்ன கட்டளைகள் அனுப்பப்படுகின்றன என்பதைப் பொருட்படுத்தாது.

ஹார்ட் டிரைவ்கள் - மடிக்கணினிகளைப் பொறுத்தவரை, 8 ஃபார்ம் ஃபேக்டரில் 7 TB திறன் கொண்ட HGST டிராவல்ஸ்டார் 1000K1 இன் 2.5 துண்டுகள். இந்த இயக்கிகள் முன்பு RAID 6 வரிசையில் இருந்தன. புதிய அமைப்பில் அவர்களுக்கும் பயன் இருக்கும். உள்ளூர் காப்புப்பிரதிகளை சேமிக்க.

கூடுதலாக சேர்க்கப்பட்டது:

6 துண்டுகள் SATA SSD மாடல் சாம்சங் 860 QVO 2TB. இந்த SSDகளுக்கு ஒரு பெரிய அளவு தேவைப்பட்டது, SLC கேச் இருப்பது, நம்பகத்தன்மை மற்றும் குறைந்த விலை ஆகியவை தேவை. நிராகரிப்பு/பூஜ்ஜியத்திற்கான ஆதரவு தேவை, இது dmesg இல் உள்ள வரியால் சரிபார்க்கப்படுகிறது:

kernel: ata1.00: Enabling discard_zeroes_data

NVMe SSD மாடலின் 2 துண்டுகள் Samsung SSD 970 EVO 500GB.

இந்த SSDகளுக்கு, சீரற்ற வாசிப்பு/எழுதுதல் வேகம் மற்றும் உங்கள் தேவைகளுக்கான ஆதார திறன் ஆகியவை முக்கியம். அவர்களுக்கு ரேடியேட்டர். அவசியம். முற்றிலும். இல்லையெனில், முதல் RAID ஒத்திசைவின் போது மிருதுவாக இருக்கும் வரை வறுக்கவும்.

8 x NVMe SSDக்கான StarTech PEX2M2E2 அடாப்டர் PCIe 3.0 8x ஸ்லாட்டில் நிறுவப்பட்டது. இது, மீண்டும், ஒரு HBA மட்டுமே, ஆனால் NVMeக்கு. உள்ளமைக்கப்பட்ட PCIe ஸ்விட்ச் இருப்பதால் மதர்போர்டில் இருந்து PCIe பிளவுபடுத்தல் ஆதரவு தேவையில்லை என்பதால் இது மலிவான அடாப்டர்களில் இருந்து வேறுபடுகிறது. இது x1 PCIe 1.0 ஸ்லாட்டாக இருந்தாலும், PCIe உடன் மிகவும் பழமையான அமைப்பில் கூட வேலை செய்யும். இயற்கையாகவே, பொருத்தமான வேகத்தில். அங்கு RAIDகள் இல்லை. போர்டில் உள்ளமைக்கப்பட்ட பயாஸ் இல்லை. எனவே, உங்கள் கணினி NVMe உடன் துவக்க மாயமாக கற்றுக்கொள்ளாது, இந்த சாதனத்திற்கு NVMe RAID நன்றி.

இந்த கூறு கணினியில் ஒரே ஒரு இலவச 8x PCIe 3.0 மட்டுமே இருப்பதால், 2 இலவச ஸ்லாட்டுகள் இருந்தால், அதை இரண்டு பைசா PEX4M2E1 அல்லது அனலாக்ஸுடன் எளிதாக மாற்றலாம், அதை எங்கும் 600 விலையில் வாங்கலாம். ரூபிள்.

அனைத்து வகையான வன்பொருள் அல்லது உள்ளமைக்கப்பட்ட சிப்செட்/பயாஸ் RAIDகளின் நிராகரிப்பு, SSD/HDD தவிர, அனைத்து தரவையும் பாதுகாக்கும் அதே வேளையில், முழு கணினியையும் முழுவதுமாக மாற்றும் வகையில் வேண்டுமென்றே செய்யப்பட்டது. முற்றிலும் புதிய/வேறு வன்பொருளுக்கு நகரும் போது நிறுவப்பட்ட இயங்குதளத்தை கூட சேமிக்க முடியும். முக்கிய விஷயம் என்னவென்றால், SATA மற்றும் PCIe போர்ட்கள் உள்ளன. இது ஒரு நேரடி குறுவட்டு அல்லது துவக்கக்கூடிய ஃபிளாஷ் டிரைவ் போன்றது, மிக வேகமாகவும் கொஞ்சம் பருமனாகவும் இருக்கும்.

நகைச்சுவைஇல்லையெனில், என்ன நடக்கும் என்று உங்களுக்குத் தெரியும் - சில நேரங்களில் நீங்கள் அவசரமாக முழு வரிசையையும் எடுத்துச் செல்ல வேண்டும். ஆனால் நான் தரவை இழக்க விரும்பவில்லை. இதைச் செய்ய, குறிப்பிடப்பட்ட அனைத்து ஊடகங்களும் நிலையான வழக்கின் 5.25 விரிகுடாக்களில் உள்ள ஸ்லைடுகளில் வசதியாக அமைந்துள்ளன.

சரி, மற்றும், நிச்சயமாக, லினக்ஸில் SSD கேச்சிங்கின் வெவ்வேறு முறைகளை பரிசோதிப்பதற்காக.

வன்பொருள் சோதனைகள் சலிப்பை ஏற்படுத்துகின்றன. அதை இயக்கவும். இது வேலை செய்கிறது அல்லது இல்லை. மற்றும் mdadm உடன் எப்போதும் விருப்பங்கள் உள்ளன.

மென்மையான

முன்னதாக, டெபியன் 8 ஜெஸ்ஸி வன்பொருளில் நிறுவப்பட்டது, இது EOL க்கு அருகில் உள்ளது. RAID 6 ஆனது LVM உடன் இணைக்கப்பட்ட மேலே குறிப்பிடப்பட்ட HDDகளில் இருந்து அசெம்பிள் செய்யப்பட்டது. இது kvm/libvirt இல் மெய்நிகர் இயந்திரங்களை இயக்கியது.

ஏனெனில் கையடக்க துவக்கக்கூடிய SATA/NVMe ஃபிளாஷ் டிரைவ்களை உருவாக்குவதில் ஆசிரியருக்கு பொருத்தமான அனுபவம் உள்ளது, மேலும் வழக்கமான பொருத்தமான டெம்ப்ளேட்டை உடைக்காமல் இருக்க, Ubuntu 18.04 இலக்கு அமைப்பாகத் தேர்ந்தெடுக்கப்பட்டது, இது ஏற்கனவே போதுமான அளவு உறுதிப்படுத்தப்பட்டுள்ளது, ஆனால் இன்னும் 3 ஆண்டுகள் உள்ளது. எதிர்காலத்தில் ஆதரவு.

குறிப்பிடப்பட்ட கணினியில் நமக்குத் தேவையான அனைத்து வன்பொருள் இயக்கிகளும் உள்ளன. எங்களுக்கு மூன்றாம் தரப்பு மென்பொருள் அல்லது இயக்கிகள் எதுவும் தேவையில்லை.

நிறுவலுக்கான தயாரிப்பு

கணினியை நிறுவ உபுண்டு டெஸ்க்டாப் படம் தேவை. சேவையக அமைப்பில் ஒருவித தீவிரமான நிறுவி உள்ளது, இது UEFI அமைப்பின் பகிர்வை ஒரு வட்டில் செலுத்துவதன் மூலம் செயலிழக்க முடியாத அதிகப்படியான சுதந்திரத்தைக் காட்டுகிறது, இது அனைத்து அழகையும் கெடுத்துவிடும். அதன்படி, இது UEFI பயன்முறையில் மட்டுமே நிறுவப்பட்டுள்ளது. எந்த விருப்பங்களையும் வழங்காது.

இதில் நாங்கள் மகிழ்ச்சியடையவில்லை.

Почему?துரதிர்ஷ்டவசமாக, UEFI துவக்கமானது துவக்க மென்பொருள் RAID உடன் மிகவும் மோசமாக இணக்கமாக உள்ளது, ஏனெனில்... UEFI ESP பகிர்வுக்கான முன்பதிவுகளை யாரும் எங்களுக்கு வழங்கவில்லை. யூ.எஸ்.பி போர்ட்டில் ஃபிளாஷ் டிரைவில் ஈஎஸ்பி பகிர்வை வைக்க பரிந்துரைக்கும் சமையல் குறிப்புகள் இணையத்தில் உள்ளன, ஆனால் இது தோல்வியின் ஒரு புள்ளியாகும். மெட்டாடேட்டா பதிப்பு 1 உடன் mdadm RAID 0.9 மென்பொருளைப் பயன்படுத்தும் சமையல் குறிப்புகள் UEFI BIOS ஐ இந்தப் பகிர்வைப் பார்ப்பதைத் தடுக்காது, ஆனால் BIOS அல்லது மற்றொரு வன்பொருள் OS ESP க்கு எதையாவது எழுதி, அதை மற்றவற்றுடன் ஒத்திசைக்க மறந்துவிடும் மகிழ்ச்சியான தருணம் வரை இது வாழ்கிறது. கண்ணாடிகள்.

கூடுதலாக, UEFI துவக்கம் NVRAM ஐப் பொறுத்தது, இது வட்டுகளுடன் புதிய கணினிக்கு நகராது, ஏனெனில் மதர்போர்டின் ஒரு பகுதியாகும்.

எனவே, நாங்கள் புதிய சக்கரத்தை மீண்டும் உருவாக்க மாட்டோம். UEFI-இணக்கமான கணினிகளில் CSM என்ற பெருமைமிக்க பெயரைத் தாங்கி, இப்போது Legacy/BIOS boot என அழைக்கப்படும், தயாராக தயாரிக்கப்பட்ட, நேரத்தைச் சோதனை செய்த தாத்தாவின் பைக் ஏற்கனவே எங்களிடம் உள்ளது. நாங்கள் அதை அலமாரியில் இருந்து எடுத்து, அதை உயவூட்டுவோம், டயர்களை பம்ப் செய்து ஈரமான துணியால் துடைப்போம்.

உபுண்டுவின் டெஸ்க்டாப் பதிப்பையும் லெகசி பூட்லோடருடன் சரியாக நிறுவ முடியாது, ஆனால் இங்கே, அவர்கள் சொல்வது போல், குறைந்தபட்சம் விருப்பங்கள் உள்ளன.

எனவே, உபுண்டு லைவ் துவக்கக்கூடிய ஃபிளாஷ் டிரைவிலிருந்து வன்பொருளைச் சேகரித்து கணினியை ஏற்றுகிறோம். நாங்கள் தொகுப்புகளைப் பதிவிறக்க வேண்டும், எனவே உங்களுக்காக வேலை செய்யும் பிணையத்தை அமைப்போம். இது வேலை செய்யவில்லை என்றால், தேவையான தொகுப்புகளை முன்கூட்டியே ஃபிளாஷ் டிரைவில் ஏற்றலாம்.

நாங்கள் டெஸ்க்டாப் சூழலுக்குச் சென்று, டெர்மினல் எமுலேட்டரைத் தொடங்குகிறோம், நாங்கள் செல்கிறோம்:

#sudo bash

எப்படி…?மேலே உள்ள வரியானது சூடோ பற்றிய ஹோலிவார்களுக்கான நியதித் தூண்டுதலாகும். சி பிоஅதிக வாய்ப்புகள் வந்து சேரும்оஅதிக பொறுப்பு. அதை நீங்களே எடுத்துக் கொள்ள முடியுமா என்பது கேள்வி. இந்த வழியில் சூடோவைப் பயன்படுத்துவது குறைந்தபட்சம் கவனமாக இல்லை என்று பலர் நினைக்கிறார்கள். எனினும்:

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

ஏன் ZFS இல்லை...?நாம் நமது கணினியில் மென்பொருளை நிறுவும் போது, ​​இந்த மென்பொருளை உருவாக்குபவர்களுக்கு ஓட்டுவதற்கு நமது வன்பொருளைக் கடனாகக் கொடுக்கிறோம்.
இந்த மென்பொருளை எங்கள் தரவுகளின் பாதுகாப்போடு நம்பும்போது, ​​இந்தத் தரவை மீட்டெடுப்பதற்கான செலவிற்கு சமமான கடனைப் பெறுகிறோம், அதை ஒரு நாள் செலுத்த வேண்டியிருக்கும்.

இந்தக் கண்ணோட்டத்தில், ZFS ஒரு ஃபெராரி, மேலும் mdadm+lvm என்பது சைக்கிள் போன்றது.

அகநிலை ரீதியாக, ஆசிரியர் ஃபெராரிக்கு பதிலாக தெரியாத நபர்களுக்கு கடனில் ஒரு பைக்கைக் கொடுக்க விரும்புகிறார். அங்கு, பிரச்சினையின் விலை அதிகமாக இல்லை. உரிமைகள் தேவையில்லை. போக்குவரத்து விதிமுறைகளை விட எளிமையானது. பார்க்கிங் இலவசம். நாடுகடந்த திறன் சிறப்பாக உள்ளது. நீங்கள் எப்போதும் ஒரு மிதிவண்டிக்கு கால்களை இணைக்கலாம், உங்கள் சொந்த கைகளால் ஒரு சைக்கிளை சரிசெய்யலாம்.

அப்புறம் ஏன் BTRFS...?ஆப்பரேட்டிங் சிஸ்டத்தை துவக்க, லெகசி/பயாஸ் க்ரப் அவுட் ஆஃப் பாக்ஸில் ஆதரிக்கப்படும் கோப்பு முறைமை நமக்குத் தேவை, அதே நேரத்தில் லைவ் ஸ்னாப்ஷாட்களையும் ஆதரிக்கிறது. /boot பகிர்வுக்கு இதைப் பயன்படுத்துவோம். கூடுதலாக, ஆசிரியர் / (ரூட்) க்கு இந்த FS ஐப் பயன்படுத்த விரும்புகிறார், வேறு எந்த மென்பொருளுக்கும் நீங்கள் LVM இல் தனித்தனி பகிர்வுகளை உருவாக்கலாம் மற்றும் அவற்றை தேவையான அடைவுகளில் ஏற்றலாம் என்பதை மறந்துவிடாதீர்கள்.

இந்த FS இல் மெய்நிகர் இயந்திரங்கள் அல்லது தரவுத்தளங்களின் படங்கள் எதையும் நாங்கள் சேமிக்க மாட்டோம்.
இந்த FS ஆனது கணினியை அணைக்காமல் ஸ்னாப்ஷாட்களை உருவாக்க மட்டுமே பயன்படுத்தப்படும், பின்னர் அனுப்பு/பெறுதலைப் பயன்படுத்தி இந்த ஸ்னாப்ஷாட்களை காப்பு வட்டுக்கு மாற்றும்.

கூடுதலாக, ஆசிரியர் பொதுவாக குறைந்தபட்ச மென்பொருளை நேரடியாக வன்பொருளில் வைத்து மற்ற எல்லா மென்பொருளையும் மெய்நிகர் கணினிகளில் இயக்க விரும்புகிறார்.

வன்பொருளில் எஞ்சியிருக்கும் விஷயங்கள் தரவு சேமிப்பு, மெய்நிகராக்கம் மற்றும் காப்புப்பிரதி மட்டுமே.

நீங்கள் 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


வட்டு தளவமைப்பு

NVMe SSD

ஆனால் நாங்கள் அவர்களை எந்த வகையிலும் குறிக்க மாட்டோம். அதே, எங்கள் BIOS இந்த இயக்கிகளைப் பார்க்கவில்லை. எனவே, அவர்கள் முற்றிலும் மென்பொருள் RAID க்கு செல்வார்கள். நாங்கள் அங்கு பிரிவுகளை கூட உருவாக்க மாட்டோம். நீங்கள் "கேனான்" அல்லது "முதன்மையாக" பின்பற்ற விரும்பினால், HDD போன்ற ஒரு பெரிய பகிர்வை உருவாக்கவும்.

SATA HDD

இங்கே சிறப்பு எதையும் கண்டுபிடிக்க வேண்டிய அவசியமில்லை. அனைத்திற்கும் ஒரு பிரிவை உருவாக்குவோம். பயாஸ் இந்த வட்டுகளைப் பார்ப்பதால், அவற்றிலிருந்து துவக்க முயற்சிப்பதால் நாம் ஒரு பகிர்வை உருவாக்குவோம். இந்த வட்டுகளில் 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 TB அளவில் உள்ளன. இது MBR க்கு ஏற்றுக்கொள்ளக்கூடிய வரம்பிற்குள் உள்ளது, இதைத்தான் நாங்கள் பயன்படுத்துவோம். தேவைப்பட்டால், GPT உடன் மாற்றலாம். GPT வட்டுகள் பொருந்தக்கூடிய அடுக்குகளைக் கொண்டுள்ளன, இது MBR-இணக்கமான கணினிகள் முதல் 4 டெராபைட்டுகளுக்குள் அமைந்திருந்தால் முதல் 2 பகிர்வுகளைப் பார்க்க அனுமதிக்கிறது. முக்கிய விஷயம் என்னவென்றால், இந்த வட்டுகளில் துவக்க பகிர்வு மற்றும் bios_grub பகிர்வு ஆரம்பத்தில் இருக்க வேண்டும். இது GPT Legacy/BIOS டிரைவ்களில் இருந்து துவக்க உங்களை அனுமதிக்கிறது.

ஆனால் இது எங்கள் வழக்கு அல்ல.

இங்கே நாம் இரண்டு பிரிவுகளை உருவாக்குவோம். முதலாவது 1 ஜிபி அளவில் இருக்கும் மற்றும் RAID 1 /bootக்கு பயன்படுத்தப்படும்.

இரண்டாவது RAID 6 க்கு பயன்படுத்தப்படும் மற்றும் இயக்ககத்தின் முடிவில் ஒரு சிறிய ஒதுக்கப்படாத பகுதியைத் தவிர மீதமுள்ள அனைத்து இடத்தையும் எடுத்துக் கொள்ளும்.

இது என்ன குறிக்கப்படாத பகுதி?நெட்வொர்க்கில் உள்ள ஆதாரங்களின்படி, எங்கள் SATA SSDகள் 6 முதல் 78 ஜிகாபைட் வரையிலான அளவுள்ள மாறும் வகையில் விரிவாக்கக்கூடிய SLC கேச் போர்டில் உள்ளது. டிரைவின் தரவுத் தாளில் உள்ள "ஜிகாபைட்" மற்றும் "ஜிபிபைட்" ஆகியவற்றுக்கு இடையே உள்ள வித்தியாசத்தின் காரணமாக 6 ஜிகாபைட்களை "இலவசமாக" பெறுகிறோம். மீதமுள்ள 72 ஜிகாபைட்கள் பயன்படுத்தப்படாத இடத்திலிருந்து ஒதுக்கப்படுகின்றன.

எங்களிடம் ஒரு SLC கேச் உள்ளது, மேலும் இடம் 4 பிட் MLC பயன்முறையில் ஆக்கிரமிக்கப்பட்டுள்ளது என்பதை இங்கே கவனத்தில் கொள்ள வேண்டும். நமக்குத் திறம்பட அதாவது ஒவ்வொரு 4 ஜிகாபைட் இலவச இடத்துக்கும் 1 ஜிகாபைட் SLC கேச் மட்டுமே கிடைக்கும்.

72 ஜிகாபைட்களை 4 ஆல் பெருக்கி 288 ஜிகாபைட்களைப் பெறுங்கள். டிரைவ்கள் SLC தற்காலிக சேமிப்பை முழுமையாகப் பயன்படுத்த அனுமதிக்கும் வகையில் நாங்கள் குறிக்காத இலவச இடம் இதுவாகும்.

இவ்வாறு, மொத்தம் ஆறு டிரைவ்களில் இருந்து 312 ஜிகாபைட்கள் வரை SLC தற்காலிக சேமிப்பை திறம்படப் பெறுவோம். அனைத்து இயக்கிகளிலும், 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


NVMe SSD

#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 வரிசைகளில் பயன்படுத்தப்படும் அனைத்து SSDகளும் 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

ஏன் இவ்வளவு பெரிய...?துண்டின் அளவை அதிகரிப்பது, துண்டின் அளவை உள்ளடக்கிய தொகுதிகளில் சீரற்ற வாசிப்பின் வேகத்தில் சாதகமான விளைவைக் கொண்டுள்ளது. இது நிகழ்கிறது, ஏனெனில் பொருத்தமான அளவு அல்லது சிறிய அளவிலான ஒரு செயல்பாட்டை ஒரு சாதனத்தில் முழுமையாக முடிக்க முடியும். எனவே, அனைத்து சாதனங்களிலிருந்தும் ஐஓபிஎஸ் சுருக்கப்பட்டுள்ளது. புள்ளிவிவரங்களின்படி, 99% IO 512K ஐ விட அதிகமாக இல்லை.

ஒரு எழுத்துக்கு RAID 6 IOPS எப்போதும் ஒரு இயக்ககத்தின் IOPS ஐ விட குறைவாக அல்லது சமமாக உள்ளது. ஒரு சீரற்ற வாசிப்பாக, IOPS ஒரு இயக்ககத்தை விட பல மடங்கு அதிகமாக இருக்கும், மேலும் தொகுதி அளவு முக்கிய முக்கியத்துவம் வாய்ந்தது.
RAID 6 பை-டிசைனில் மோசமான ஒரு அளவுருவை மேம்படுத்த முயற்சிப்பதில் உள்ள புள்ளியை ஆசிரியர் பார்க்கவில்லை, அதற்கு பதிலாக RAID 6 எது சிறந்தது என்பதை மேம்படுத்துகிறார்.
NVMe கேச் மற்றும் மெல்லிய வழங்கல் தந்திரங்கள் மூலம் RAID 6 இன் மோசமான சீரற்ற எழுதுதலுக்கு ஈடுசெய்வோம்.

RAID 6 க்கு DISCARD ஐ இன்னும் செயல்படுத்தவில்லை. எனவே இந்த வரிசையை இப்போதைக்கு "தொடக்க" மாட்டோம். OS ஐ நிறுவிய பின் இதை செய்வோம்.

SATA HDD

#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.
இருப்பினும், ஸ்வாப், மெட்டாடேட்டா மற்றும் எல்விஎம்-கேச் மற்றும் எல்விஎம்-தின் மெட்டாடேட்டா போன்ற பிற தேவைகளுக்கு இந்த வேகமான வரிசை இன்னும் தேவைப்படும், எனவே இந்த வரிசையில் எல்விஎம் விஜியை உருவாக்குவோம்.

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

ரூட் கோப்பு முறைமைக்கான பகிர்வை உருவாக்குவோம்.

#lvcreate -L 128G --name root root

ரேமின் அளவுக்கேற்ப இடமாற்றத்திற்கான பகிர்வை உருவாக்குவோம்.

#lvcreate -L 32G --name swap root

OS நிறுவல்

மொத்தத்தில், கணினியை நிறுவ தேவையான அனைத்தும் எங்களிடம் உள்ளன.

உபுண்டு லைவ் சூழலில் இருந்து கணினி நிறுவல் வழிகாட்டியைத் தொடங்கவும். சாதாரண நிறுவல். நிறுவலுக்கான வட்டுகளைத் தேர்ந்தெடுக்கும் கட்டத்தில் மட்டுமே, நீங்கள் பின்வருவனவற்றைக் குறிப்பிட வேண்டும்:

• /dev/md1, - மவுண்ட் பாயிண்ட் /boot, FS - BTRFS
• /dev/root/root (aka /dev/mapper/root-root), - mount point / (root), FS - BTRFS
• /dev/root/swap (aka /dev/mapper/root-swap), - swap பகிர்வாக பயன்படுத்தவும்
• துவக்க ஏற்றியை /dev/sda இல் நிறுவவும்

நீங்கள் BTRFS ஐ ரூட் கோப்பு முறைமையாக தேர்ந்தெடுக்கும் போது, ​​நிறுவி தானாகவே இரண்டு BTRFS தொகுதிகளை உருவாக்குகிறது.

நிறுவலை தொடங்குவோம்...

பூட்லோடரை நிறுவுவதில் பிழையைக் குறிக்கும் மாதிரி உரையாடல் பெட்டியுடன் நிறுவல் முடிவடையும். துரதிர்ஷ்டவசமாக, நிலையான வழிமுறைகளைப் பயன்படுத்தி இந்த உரையாடலில் இருந்து வெளியேறி நிறுவலைத் தொடர முடியாது. நாங்கள் கணினியிலிருந்து வெளியேறி மீண்டும் உள்நுழைந்து, சுத்தமான உபுண்டு லைவ் டெஸ்க்டாப்பில் முடிவடையும். முனையத்தைத் திறந்து, மீண்டும்:

#sudo bash

நிறுவலைத் தொடர chroot சூழலை உருவாக்கவும்:

#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 க்கு போதுமானதாக அமைக்கவும். இயல்புநிலை மதிப்பு, லினக்ஸ் உருவாக்கப்பட்டதிலிருந்து மாறவில்லை, நீண்ட காலமாக போதுமானதாக இல்லை.
• வரிசை சரிபார்ப்புகள்/ஒத்திசைவுகளின் காலத்திற்கு குறைந்தபட்சம் IO ஐ ஒதுக்கவும். சுமையின் கீழ் நித்திய ஒத்திசைவு நிலையில் உங்கள் அணிவரிசைகள் சிக்கிக் கொள்வதைத் தடுக்க இது உள்ளது.
• வரிசைகளின் சரிபார்ப்பு/ஒத்திசைவின் போது அதிகபட்ச IO ஐ வரம்பிடவும். SSD RAIDகளை ஒத்திசைத்தல்/சரிபார்ப்பது உங்கள் டிரைவ்களை மிருதுவாக வறுக்காமல் இருக்க இது அவசியம். இது குறிப்பாக NVMe க்கு பொருந்தும். (ரேடியேட்டரைப் பற்றி நினைவிருக்கிறதா? நான் கேலி செய்யவில்லை.)
• APM வழியாக சுழல் சுழற்சியை (HDD) நிறுத்துவதில் இருந்து வட்டுகளைத் தடைசெய்து, டிஸ்க் கன்ட்ரோலர்களுக்கான தூக்க நேரத்தை 7 மணிநேரமாக அமைக்கவும். உங்கள் டிரைவ்களால் APMஐ முழுவதுமாக முடக்கலாம் (-B 255). இயல்புநிலை மதிப்புடன், டிரைவ்கள் ஐந்து வினாடிகளுக்குப் பிறகு நிறுத்தப்படும். பின்னர் 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 பகிர்வைத் தேடுவோம். வரிசை பெயரிடுதல் கோட்பாட்டளவில் மாறலாம்.

மீதமுள்ள பிரிவுகளை LVM பெயர்களால் /dev/mapper/vg-lv குறியீட்டில் தேடுவோம், ஏனெனில் அவை பகிர்வுகளை தனித்துவமாக அடையாளப்படுத்துகின்றன.

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 கேச் மெட்டாடேட்டாவைக் கொண்ட சாதனங்கள் (cmeta)
• பெயர் படங்களுடன் VG இல் உள்ள அனைத்து சாதனங்களும். இங்கே எங்களிடம் மெய்நிகர் இயந்திரங்களின் வட்டு படங்கள் இருக்கும், மேலும் விருந்தினர் OS க்கு சொந்தமான தொகுதிகளை ஹோஸ்டில் உள்ள LVM செயல்படுத்துவதை நாங்கள் விரும்பவில்லை.
• பெயர் காப்புப்பிரதியுடன் VG இல் உள்ள அனைத்து சாதனங்களும். மெய்நிகர் இயந்திரப் படங்களின் காப்பு பிரதிகள் இங்கே இருக்கும்.
• "gpv" (விருந்தினர் உடல் அளவு) என்று முடிவடையும் அனைத்து சாதனங்களும்

LVM VG இல் இலவச இடத்தை விடுவிக்கும் போது டிஸ்கார்ட் ஆதரவை இயக்கியுள்ளோம். கவனமாக இரு. இது SSD இல் எல்விகளை நீக்குவதற்கு அதிக நேரத்தை எடுத்துக்கொள்ளும். இது குறிப்பாக SSD RAID 6 க்கு பொருந்தும். இருப்பினும், திட்டத்தின் படி, நாம் மெல்லிய வழங்கலைப் பயன்படுத்துவோம், எனவே இது நமக்குத் தடையாக இருக்காது.

initramfs படத்தை புதுப்பிப்போம்:

#update-initramfs -u -k all

grub ஐ நிறுவி உள்ளமைக்கவும்:

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

எந்த வட்டுகளை தேர்வு செய்வது?எஸ்டி* உள்ள அனைவரும். எந்த வேலை செய்யும் SATA டிரைவ் அல்லது SSD இலிருந்து கணினியை துவக்க முடியும்.

ஏன் os-prober ஐ சேர்த்தார்கள்..?அதிகப்படியான சுதந்திரம் மற்றும் விளையாட்டுத்தனமான கைகளுக்கு.

RAIDகளில் ஒன்று சிதைந்த நிலையில் இருந்தால் அது சரியாக வேலை செய்யாது. இந்த வன்பொருளில் இயங்கும் மெய்நிகர் கணினிகளில் பயன்படுத்தப்படும் பகிர்வுகளில் OS ஐத் தேட முயற்சிக்கிறது.

உங்களுக்குத் தேவைப்பட்டால், நீங்கள் அதை விட்டுவிடலாம், ஆனால் மேலே உள்ள அனைத்தையும் நினைவில் கொள்ளுங்கள். ஆன்லைனில் குறும்பு கைகளை அகற்றுவதற்கான சமையல் குறிப்புகளைத் தேட பரிந்துரைக்கிறேன்.

இதன் மூலம் ஆரம்ப நிறுவலை முடித்துள்ளோம். புதிதாக நிறுவப்பட்ட OS இல் மறுதொடக்கம் செய்ய வேண்டிய நேரம் இது. துவக்கக்கூடிய நேரடி CD/USB ஐ அகற்ற மறக்காதீர்கள்.

#exit
#reboot

துவக்க சாதனமாக SATA SSDகளில் ஏதேனும் ஒன்றைத் தேர்ந்தெடுக்கவும்.

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-க்குள் அவர்களை அடைப்பதன் மூலம் நீங்கள் அவர்களுக்கு ஒரு பொதுவான தோல்வியை உருவாக்கக்கூடாது.

"வன்பொருள்" மட்டத்தில் எல்விஎம் இருப்பதால், வெவ்வேறு RAID வரிசைகளின் துண்டுகளை வெவ்வேறு வழிகளில் இணைப்பதன் மூலம் தன்னிச்சையாக வெட்ட அனுமதிக்கும். உதாரணமாக - ரன் ஒரே நேரத்தில் bcache + LVM thin, bcache + BTRFS, LVM cache + LVM மெல்லிய, தற்காலிக சேமிப்புகளுடன் கூடிய சிக்கலான ZFS உள்ளமைவு அல்லது வேறு ஏதேனும் நரகக் கலவையை முயற்சி செய்து அனைத்தையும் ஒப்பிட்டுப் பார்க்கவும்.

"வன்பொருள்" மட்டத்தில், நல்ல பழைய "தடித்த" LVM தொகுதிகளைத் தவிர வேறு எதையும் பயன்படுத்த மாட்டோம். இந்த விதிக்கு விதிவிலக்கு காப்புப் பகிர்வாக இருக்கலாம்.

இந்த நேரத்தில், பல வாசகர்கள் ஏற்கனவே கூடு கட்டும் பொம்மையைப் பற்றி சந்தேகிக்கத் தொடங்கினர் என்று நினைக்கிறேன்.

SATA HDD இல் LVM

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

மீண்டும் புதிய விஜி..?தரவு காப்புப்பிரதிக்கு நாங்கள் பயன்படுத்தும் வட்டு வரிசை தோல்வியுற்றால், எங்கள் இயக்க முறைமை வழக்கம் போல் தொடர்ந்து செயல்படும், அதே நேரத்தில் காப்புப்பிரதி அல்லாத தரவுகளுக்கான அணுகலைப் பராமரிக்க வேண்டும். எனவே, VG செயல்படுத்தல் சிக்கல்களைத் தவிர்க்க, நாங்கள் ஒரு தனி VG ஐ உருவாக்குகிறோம்.

LVM தற்காலிக சேமிப்பை அமைக்கிறது

NVMe RAID 1 இல் ஒரு எல்வியை உருவாக்கி, அதை கேச்சிங் சாதனமாகப் பயன்படுத்துவோம்.

#lvcreate -L 70871154688B --name cache root

ஏன் இவ்வளவு குறைவு...?உண்மை என்னவென்றால், எங்கள் NVMe SSD களிலும் SLC கேச் உள்ளது. 4 ஜிகாபைட் "இலவசம்" மற்றும் 18 ஜிகாபைட் டைனமிக் 3-பிட் MLC இல் ஆக்கிரமிக்கப்பட்ட இலவச இடத்தின் காரணமாக. இந்த தற்காலிகச் சேமிப்பு தீர்ந்தவுடன், NVMe SSDகள் தற்காலிக சேமிப்புடன் கூடிய SATA SSD ஐ விட அதிக வேகத்தில் இருக்காது. உண்மையில், இந்த காரணத்திற்காக, எல்விஎம் கேச் பகிர்வை என்விஎம் டிரைவின் எஸ்எல்சி கேச் அளவை விட இரண்டு மடங்கு பெரியதாக மாற்றுவதில் எந்த அர்த்தமும் இல்லை. பயன்படுத்தப்படும் NVMe இயக்கிகளுக்கு, 32-64 ஜிகாபைட் தற்காலிக சேமிப்பை உருவாக்குவது நியாயமானது என்று ஆசிரியர் கருதுகிறார்.

கொடுக்கப்பட்ட பகிர்வு அளவு 64 ஜிகாபைட் கேச், கேச் மெட்டாடேட்டா மற்றும் மெட்டாடேட்டா காப்புப்பிரதியை ஒழுங்கமைக்க வேண்டும்.

கூடுதலாக, அழுக்கு கணினி பணிநிறுத்தத்திற்குப் பிறகு, LVM முழு தற்காலிக சேமிப்பையும் அழுக்காகக் குறிக்கும் மற்றும் மீண்டும் ஒத்திசைக்கும். மேலும், கணினி மீண்டும் துவக்கப்படும் வரை இந்த சாதனத்தில் lvchange பயன்படுத்தப்படும் ஒவ்வொரு முறையும் இது மீண்டும் மீண்டும் செய்யப்படும். எனவே, பொருத்தமான ஸ்கிரிப்டைப் பயன்படுத்தி உடனடியாக தற்காலிக சேமிப்பை மீண்டும் உருவாக்க பரிந்துரைக்கிறேன்.

SATA RAID 6 இல் ஒரு எல்வியை உருவாக்கி, அதை தற்காலிக சேமிப்பு சாதனமாகப் பயன்படுத்துவோம்.

#lvcreate -L 3298543271936B --name cache data

ஏன் மூன்று டெராபைட் மட்டும்..?எனவே, தேவைப்பட்டால், நீங்கள் வேறு சில தேவைகளுக்கு SATA SSD RAID 6 ஐப் பயன்படுத்தலாம். தற்காலிக சேமிப்பு இடத்தின் அளவை இயக்கத்தில், கணினியை நிறுத்தாமல், மாறும் வகையில் அதிகரிக்கலாம். இதைச் செய்ய, நீங்கள் தற்காலிகமாக தற்காலிக சேமிப்பை நிறுத்தி மீண்டும் இயக்க வேண்டும், ஆனால் எல்விஎம்-கேச்சின் தனித்துவமான நன்மை, எடுத்துக்காட்டாக, bcache இது பறக்கும் போது செய்யப்படலாம்.

கேச்சிங்கிற்காக புதிய VG ஐ உருவாக்குவோம்.

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

கேச் செய்யப்பட்ட சாதனத்தில் எல்வியை உருவாக்குவோம்.

#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

ஏன் இப்படி துண்டாடுவது..?நடைமுறைச் சோதனைகள் மூலம், எல்விஎம் கேச் பிளாக்கின் அளவு எல்விஎம் மெல்லிய பிளாக்கின் அளவோடு ஒத்துப் போனால், சிறந்த முடிவு கிடைக்கும் என்பதை ஆசிரியரால் கண்டறிய முடிந்தது. மேலும், சிறிய அளவு, சீரற்ற பதிவில் உள்ளமைவு சிறப்பாக செயல்படுகிறது.

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)

/dev/data/cache இல் [cachedata_corig] மட்டுமே இருக்க வேண்டும். ஏதேனும் தவறு இருந்தால், 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

எதற்காக..?இங்கே கேள்வி எழலாம்: எல்விஎம் மெல்லிய மெட்டாடேட்டாவை இன்னும் என்விஎம்இயில் தேக்ககப்படுத்தப்பட்டு விரைவாக வேலை செய்யும் எனில் அதை ஏன் தனித்தனியாக வைக்க வேண்டும்.

வேகம் இங்கே முக்கியமானது என்றாலும், அது முக்கிய காரணத்திலிருந்து வெகு தொலைவில் உள்ளது. விஷயம் என்னவென்றால், கேச் தோல்வியின் ஒரு புள்ளியாகும். அதற்கு ஏதாவது நடக்கலாம், மேலும் எல்விஎம் மெல்லிய மெட்டாடேட்டாவை தேக்ககப்படுத்தினால், அது அனைத்தையும் முற்றிலும் இழக்கச் செய்யும். முழுமையான மெட்டாடேட்டா இல்லாமல், மெல்லிய தொகுதிகளை ஒன்று சேர்ப்பது கிட்டத்தட்ட சாத்தியமற்றது.

மெட்டாடேட்டாவை தற்காலிக சேமிப்பில் இல்லாத, ஆனால் வேகமான தொகுதிக்கு நகர்த்துவதன் மூலம், கேச் இழப்பு அல்லது சிதைவு ஏற்பட்டால், மெட்டாடேட்டாவின் பாதுகாப்பிற்கு நாங்கள் உத்தரவாதம் அளிக்கிறோம். இந்த வழக்கில், கேச் இழப்பால் ஏற்படும் அனைத்து சேதங்களும் மெல்லிய தொகுதிகளுக்குள் உள்ளூர்மயமாக்கப்படும், இது அளவின் உத்தரவுகளால் மீட்பு செயல்முறையை எளிதாக்கும். அதிக நிகழ்தகவுடன், இந்த சேதங்கள் FS பதிவுகளைப் பயன்படுத்தி மீட்டமைக்கப்படும்.

மேலும், ஒரு மெல்லிய தொகுதியின் ஸ்னாப்ஷாட் முன்பு எடுக்கப்பட்டிருந்தால், அதன் பிறகு தற்காலிக சேமிப்பு ஒரு முறையாவது முழுமையாக ஒத்திசைக்கப்பட்டிருந்தால், LVM மெல்லிய உள் வடிவமைப்பு காரணமாக, கேச் இழப்பு ஏற்பட்டால் ஸ்னாப்ஷாட்டின் ஒருமைப்பாடு உத்தரவாதம் அளிக்கப்படும். .

மெல்லிய வழங்கலுக்குப் பொறுப்பான புதிய 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
ஏன் -இசட் ஒய்இந்த பயன்முறை உண்மையில் எதை நோக்கமாகக் கொண்டுள்ளது என்பதைத் தவிர - இடத்தை மறுபகிர்வு செய்யும் போது ஒரு மெய்நிகர் இயந்திரத்திலிருந்து மற்றொரு மெய்நிகர் இயந்திரத்திற்கு தரவு கசிவதைத் தடுக்க - 64k க்கும் குறைவான தொகுதிகளில் சீரற்ற எழுத்தின் வேகத்தை அதிகரிக்க பூஜ்ஜியம் கூடுதலாகப் பயன்படுத்தப்படுகிறது. 64k க்கும் குறைவாக எழுதும் மெல்லிய தொகுதியின் முன்பு ஒதுக்கப்படாத பகுதிக்கு 64K விளிம்பில் சீரமைக்கப்படும். தற்காலிக சேமிப்பு சாதனத்தைத் தவிர்த்து, தற்காலிக சேமிப்பின் மூலம் செயல்பாட்டை முழுமையாகச் செய்ய இது அனுமதிக்கும்.

LVகளை தொடர்புடைய 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 வினாடிகளுக்கு இயங்கும். பாதிப் பரீட்சைகள் பதிவிற்கானவை. நீங்கள் 4 வினாடிகளில் NVMe இல் நிறைய பதிவு செய்யலாம். வினாடிக்கு 3 ஜிகாபைட் வரை. எனவே, எழுதும் சோதனைகளின் ஒவ்வொரு ஓட்டமும் உங்களிடமிருந்து 216 ஜிகாபைட் SSD வளத்தை உண்ணலாம்.

வாசிப்பும் எழுத்தும் கலந்ததா?ஆம். படிக்கவும் எழுதவும் தேர்வுகளை தனித்தனியாக நடத்துவது அர்த்தமுள்ளதாக இருக்கும். மேலும், அனைத்து தற்காலிக சேமிப்புகளும் ஒத்திசைக்கப்படுவதை உறுதிசெய்வது அர்த்தமுள்ளதாக இருக்கிறது, இதனால் முன்பு எழுதப்பட்டவை வாசிப்பைப் பாதிக்காது.

முதல் வெளியீட்டின் போது முடிவுகள் பெரிதும் மாறுபடும் மற்றும் கேச் மற்றும் மெல்லிய வால்யூம் நிரம்பிய பின் வரும் முடிவுகள், மேலும் கடைசி வெளியீட்டின் போது நிரப்பப்பட்ட தற்காலிகச் சேமிப்புகளை கணினியால் ஒத்திசைக்க முடிந்ததா என்பதைப் பொறுத்தும் இருக்கும்.

மற்றவற்றுடன், ஒரு ஸ்னாப்ஷாட் எடுக்கப்பட்ட ஏற்கனவே முழு மெல்லிய தொகுதியில் வேகத்தை அளவிட பரிந்துரைக்கிறேன். முதல் ஸ்னாப்ஷாட்டை உருவாக்கிய உடனேயே சீரற்ற எழுத்துக்கள் எவ்வாறு கூர்மையாக முடுக்கிவிடப்படுகின்றன என்பதைக் கவனிக்க ஆசிரியருக்கு வாய்ப்பு கிடைத்தது, குறிப்பாக தற்காலிக சேமிப்பு இன்னும் முழுமையாக நிரம்பவில்லை. நகல்-ஆன்-ரைட் ரைட் செமாண்டிக்ஸ், கேச் சீரமைத்தல் மற்றும் மெல்லிய தொகுதி தொகுதிகள் மற்றும் RAID 6 க்கு ஒரு சீரற்ற எழுதுதல் RAID 6 இலிருந்து ஒரு சீரற்ற வாசிப்பாக மாறும், அதைத் தொடர்ந்து தற்காலிக சேமிப்பிற்கு எழுதுதல் ஆகியவற்றால் இது நிகழ்கிறது. எங்கள் உள்ளமைவில், RAID 6 இலிருந்து சீரற்ற வாசிப்பு 6 மடங்கு வரை (வரிசையில் உள்ள SATA SSDகளின் எண்ணிக்கை) எழுதுவதை விட வேகமாக இருக்கும். ஏனெனில் CW க்கான தொகுதிகள் ஒரு மெல்லிய குளத்திலிருந்து தொடர்ச்சியாக ஒதுக்கப்படுகின்றன, பின்னர் பதிவு, பெரும்பாலும், வரிசையாக மாறும்.

இந்த இரண்டு அம்சங்களையும் உங்கள் நன்மைக்காகப் பயன்படுத்தலாம்.

கேச் "ஒத்திசைவான" ஸ்னாப்ஷாட்கள்

கேச் சேதம்/இழப்பு ஏற்பட்டால் தரவு இழப்பின் அபாயத்தைக் குறைக்க, இந்த விஷயத்தில் அவற்றின் நேர்மைக்கு உத்தரவாதம் அளிக்க ஸ்னாப்ஷாட்களை சுழலும் நடைமுறையை அறிமுகப்படுத்த ஆசிரியர் முன்மொழிகிறார்.

முதலாவதாக, மெல்லிய தொகுதி மெட்டாடேட்டா சேமிக்கப்படாத சாதனத்தில் இருப்பதால், மெட்டாடேட்டா சீரானதாக இருக்கும் மற்றும் சாத்தியமான இழப்புகள் தரவுத் தொகுதிகளுக்குள் தனிமைப்படுத்தப்படும்.

பின்வரும் ஸ்னாப்ஷாட் சுழற்சி சுழற்சியானது கேச் இழப்பு ஏற்பட்டால் ஸ்னாப்ஷாட்களுக்குள் இருக்கும் தரவின் ஒருமைப்பாட்டிற்கு உத்தரவாதம் அளிக்கிறது:

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 SSDகள் 100% எழுதும் சுமையின் கீழ் உள்ள வளத்தை முழுவதுமாக தீர்ந்துவிடும் 3-XNUM நாட்கள். SATA SSDகள் இரண்டு மடங்கு மட்டுமே நீடிக்கும். எனவே, பெரும்பாலான சுமை வாசிப்புக்குச் செல்கிறது என்று கருதுவோம், மேலும் எழுதுவதற்கு சராசரியாக குறைந்த சுமையுடன் கூடிய மிக உயர்ந்த செயல்பாட்டின் ஒப்பீட்டளவில் குறுகிய கால வெடிப்புகள் உள்ளன.
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% சுய-கற்பித்தவர் மற்றும் "Google"-உந்துதல் வளர்ச்சியைப் பயிற்சி செய்கிறார், எனவே அவர் தனது கைகளில் இருந்து வரும் பயங்கரமான குறியீட்டை யாரும் பயன்படுத்தக்கூடாது என்று நம்புகிறார். வேறு.

இந்தத் துறையில் உள்ள வல்லுநர்கள், தேவைப்பட்டால், மேலே விவரிக்கப்பட்ட அனைத்து தர்க்கங்களையும் சுயாதீனமாக சித்தரிக்க முடியும் என்று நான் நினைக்கிறேன், மேலும், ஆசிரியர் செய்ய முயற்சித்ததைப் போல, அதை ஒரு systemd சேவையாக அழகாக வடிவமைக்க முடியும்.

இத்தகைய எளிய ஸ்னாப்ஷாட் சுழற்சித் திட்டம் 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 களில் இருந்து இத்தகைய நிராகரிப்புகள் 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 send/recieve ஐப் பயன்படுத்தி மற்றொரு 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/ துணை அடைவுகளில் தோன்றும்.

குறியீடு செயல்படுத்தும் உரிமைகளை வழங்குவோம்:

#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 மெல்லிய மெட்டாடேட்டாவிற்கு நன்றி, உண்மையில் எந்தெந்த தொகுதிகள் பயன்பாட்டில் உள்ளன என்பதை நாங்கள் அறிவோம், எனவே உண்மையில் பயன்படுத்தப்படும் மெல்லிய தொகுதி தொகுதிகள் மட்டுமே நகலெடுக்கப்படும்.

எல்விஎம் மெல்லிய மெட்டாடேட்டா வழியாக டிராக்கிங்கை மாற்றியதன் மூலம் அடுத்தடுத்த ரன்கள் தரவை படிப்படியாக நகலெடுக்கும்.

என்ன நடந்தது என்று பார்ப்போம்:

#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 அதீத நெகிழ்வுத்தன்மையை அளிக்கிறது.

சோசலிஸ்ட் கட்சி

அடுத்த கட்டுரையில், ஹோம் டெஸ்க்டாப்கள், ஹோம் இன்டர்நெட் மற்றும் P2P நெட்வொர்க்குகளைப் பயன்படுத்தி பல கண்டங்களில் பணிநீக்கத்துடன் கூடிய புவி-விநியோகிக்கப்பட்ட சேமிப்பகம்/விஎம் கிளஸ்டரை உருவாக்குவதற்கு அடிப்படையாக பல மொபைல் சேமிப்பக அமைப்புகள்/கேவிஎம்களைப் பயன்படுத்த முயற்சிப்போம்.

ஆதாரம்: www.habr.com