എൽവിഎമ്മിനും മാട്രിയോഷ്കയ്ക്കും പൊതുവായുള്ളത് എന്താണ്?

പകലിന്റെ സമയം.
md RAID + LVM ഉപയോഗിച്ച് കെവിഎമ്മിനായി ഒരു ഡാറ്റ സ്റ്റോറേജ് സിസ്റ്റം നിർമ്മിക്കുന്നതിനുള്ള എന്റെ പ്രായോഗിക അനുഭവം കമ്മ്യൂണിറ്റിയുമായി പങ്കിടാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

പ്രോഗ്രാമിൽ ഉൾപ്പെടും:

• 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 ചിപ്‌സെറ്റുള്ള മദർബോർഡ്, ഇന്റൽ കോർ i7 / ഹാസ്‌വെല്ലിനൊപ്പം.

• പ്രോസസ്സർ 4 കോറുകൾ, 8 ത്രെഡുകൾ
• 32 ജിബി 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 മോഡിലേക്ക് ഫ്ലാഷ് ചെയ്തു. റെയ്ഡ് പ്രവർത്തനക്ഷമമാക്കിയ ഫേംവെയറുകൾ മനഃപൂർവ്വം HBA ഫേംവെയർ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിച്ചു:

1. നിങ്ങൾക്ക് എപ്പോൾ വേണമെങ്കിലും ഈ അഡാപ്റ്റർ വലിച്ചെറിയുകയും നിങ്ങൾ കണ്ട മറ്റേതെങ്കിലും ഒന്ന് ഉപയോഗിച്ച് അത് മാറ്റിസ്ഥാപിക്കുകയും ചെയ്യാം.
2. TRIM/Discard സാധാരണയായി ഡിസ്കുകളിൽ പ്രവർത്തിക്കുന്നു, കാരണം... RAID ഫേംവെയറിൽ ഈ കമാൻഡുകൾ ഒട്ടും പിന്തുണയ്ക്കുന്നില്ല, കൂടാതെ HBA, പൊതുവേ, ബസിലൂടെ എന്ത് കമാൻഡുകൾ കൈമാറ്റം ചെയ്യപ്പെടുന്നു എന്നത് ശ്രദ്ധിക്കുന്നില്ല.

ഹാർഡ് ഡ്രൈവുകൾ - 8 ഫോം ഫാക്ടറിൽ 7 TB ശേഷിയുള്ള HGST ട്രാവൽസ്റ്റാർ 1000K1-ന്റെ 2.5 കഷണങ്ങൾ, ലാപ്‌ടോപ്പുകൾ പോലെ. ഈ ഡ്രൈവുകൾ മുമ്പ് ഒരു RAID 6 അറേയിലായിരുന്നു. പുതിയ സംവിധാനത്തിൽ അവർക്കും പ്രയോജനമുണ്ടാകും. പ്രാദേശിക ബാക്കപ്പുകൾ സംഭരിക്കുന്നതിന്.

അധികമായി ചേർത്തു:

6 കഷണങ്ങൾ SATA SSD മോഡൽ Samsung 860 QVO 2TB. ഈ SSD-കൾക്ക് ഒരു വലിയ വോളിയം ആവശ്യമാണ്, ഒരു SLC കാഷെയുടെ സാന്നിധ്യം, വിശ്വാസ്യത, കുറഞ്ഞ വില എന്നിവ ആവശ്യമാണ്. ഡിസ്കാർഡ്/പൂജ്യം എന്നതിനുള്ള പിന്തുണ ആവശ്യമാണ്, ഇത് dmesg-ലെ ലൈൻ പരിശോധിക്കുന്നു:

kernel: ata1.00: Enabling discard_zeroes_data

NVMe SSD മോഡൽ Samsung SSD 2 EVO 970GB-യുടെ 500 കഷണങ്ങൾ.

ഈ SSD-കൾക്കായി, ക്രമരഹിതമായ വായന/എഴുത്ത് വേഗതയും നിങ്ങളുടെ ആവശ്യങ്ങൾക്കുള്ള വിഭവശേഷിയും പ്രധാനമാണ്. അവർക്കുള്ള റേഡിയേറ്റർ. നിർബന്ധമായും. തികച്ചും. അല്ലാത്തപക്ഷം, ആദ്യത്തെ റെയിഡ് സിൻക്രൊണൈസേഷൻ സമയത്ത് ക്രിസ്പി ആകുന്നത് വരെ ഫ്രൈ ചെയ്യുക.

PCIe 8 2x സ്ലോട്ടിൽ 2 x NVMe SSD-നുള്ള StarTech PEX2M3.0E8 അഡാപ്റ്റർ ഇൻസ്റ്റാൾ ചെയ്തു. ഇത് വീണ്ടും ഒരു HBA മാത്രമാണ്, എന്നാൽ NVMe-യ്ക്ക്. ബിൽറ്റ്-ഇൻ പിസിഐഇ സ്വിച്ചിന്റെ സാന്നിധ്യം കാരണം മദർബോർഡിൽ നിന്ന് പിസിഐഇ വിഭജന പിന്തുണ ആവശ്യമില്ലാത്തതിനാൽ ഇത് വിലകുറഞ്ഞ അഡാപ്റ്ററുകളിൽ നിന്ന് വ്യത്യസ്തമാണ്. x1 PCIe 1.0 സ്ലോട്ട് ആണെങ്കിൽ പോലും, PCIe ഉള്ള ഏറ്റവും പുരാതനമായ സിസ്റ്റത്തിൽ പോലും ഇത് പ്രവർത്തിക്കും. സ്വാഭാവികമായും, ഉചിതമായ വേഗതയിൽ. അവിടെ റെയ്ഡുകളൊന്നുമില്ല. ബോർഡിൽ ബിൽറ്റ്-ഇൻ ബയോസ് ഇല്ല. അതിനാൽ, നിങ്ങളുടെ സിസ്റ്റം NVMe ഉപയോഗിച്ച് ബൂട്ട് ചെയ്യാൻ മാന്ത്രികമായി പഠിക്കില്ല, ഈ ഉപകരണത്തിന് നന്ദി NVMe RAID വളരെ കുറവാണ്.

ഈ ഘടകം സിസ്റ്റത്തിൽ ഒരു സൗജന്യ 8x PCIe 3.0 മാത്രമുള്ളതുകൊണ്ടാണ്, കൂടാതെ 2 സൗജന്യ സ്ലോട്ടുകൾ ഉണ്ടെങ്കിൽ, അത് രണ്ട് പെന്നി PEX4M2E1 അല്ലെങ്കിൽ അനലോഗ് ഉപയോഗിച്ച് എളുപ്പത്തിൽ മാറ്റിസ്ഥാപിക്കാം, അത് 600 വിലയ്ക്ക് എവിടെയും വാങ്ങാം. റൂബിൾസ്.

എല്ലാത്തരം ഹാർഡ്‌വെയറുകളുടെയും അല്ലെങ്കിൽ ബിൽറ്റ്-ഇൻ ചിപ്‌സെറ്റ്/ബയോസ് റെയ്‌ഡുകളുടെയും നിരസിക്കൽ ബോധപൂർവം ഉണ്ടാക്കിയതാണ്, എല്ലാ ഡാറ്റയും സംരക്ഷിച്ചുകൊണ്ട്, SSD/HDD ഒഴികെ, മുഴുവൻ സിസ്റ്റത്തെയും പൂർണ്ണമായും മാറ്റിസ്ഥാപിക്കാൻ കഴിയും. തികച്ചും പുതിയ/വ്യത്യസ്‌ത ഹാർഡ്‌വെയറിലേക്ക് മാറുമ്പോൾ ഇൻസ്റ്റാൾ ചെയ്ത ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പോലും നിങ്ങൾക്ക് സംരക്ഷിക്കാൻ കഴിയും. SATA, PCIe പോർട്ടുകൾ ഉണ്ട് എന്നതാണ് പ്രധാന കാര്യം. ഇത് ഒരു തത്സമയ സിഡി അല്ലെങ്കിൽ ബൂട്ടബിൾ ഫ്ലാഷ് ഡ്രൈവ് പോലെയാണ്, വളരെ വേഗതയുള്ളതും അൽപ്പം വലുതും മാത്രം.

നർമ്മംഅല്ലാത്തപക്ഷം, എന്താണ് സംഭവിക്കുന്നതെന്ന് നിങ്ങൾക്കറിയാം - ചിലപ്പോൾ നിങ്ങൾ അടിയന്തിരമായി മുഴുവൻ അറേയും നിങ്ങളോടൊപ്പം കൊണ്ടുപോകേണ്ടതുണ്ട്. എന്നാൽ ഡാറ്റ നഷ്ടപ്പെടുത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നില്ല. ഇത് ചെയ്യുന്നതിന്, സൂചിപ്പിച്ച എല്ലാ മീഡിയകളും സ്റ്റാൻഡേർഡ് കേസിന്റെ 5.25 ബേകളിലെ സ്ലൈഡുകളിൽ സൗകര്യപ്രദമായി സ്ഥിതിചെയ്യുന്നു.

ശരി, തീർച്ചയായും, ലിനക്സിൽ എസ്എസ്ഡി കാഷിംഗ് രീതികൾ പരീക്ഷിക്കുന്നതിന്.

ഹാർഡ്‌വെയർ റെയ്ഡുകൾ വിരസമാണ്. അത് ഓണാക്കുക. ഒന്നുകിൽ ഇത് പ്രവർത്തിക്കുന്നു അല്ലെങ്കിൽ പ്രവർത്തിക്കുന്നില്ല. കൂടാതെ mdadm-ൽ എപ്പോഴും ഓപ്ഷനുകൾ ഉണ്ട്.

സോഫ്റ്റ്വെയർ

മുമ്പ്, EOL-ന് അടുത്തുള്ള ഹാർഡ്‌വെയറിൽ ഡെബിയൻ 8 ജെസ്സി ഇൻസ്റ്റാൾ ചെയ്തിരുന്നു. എൽവിഎമ്മുമായി ജോടിയാക്കിയ മുകളിൽ സൂചിപ്പിച്ച HDD-കളിൽ നിന്നാണ് RAID 6 അസംബിൾ ചെയ്തത്. ഇത് kvm/libvirt-ൽ വെർച്വൽ മെഷീനുകൾ പ്രവർത്തിപ്പിച്ചു.

കാരണം പോർട്ടബിൾ ബൂട്ടബിൾ SATA/NVMe ഫ്ലാഷ് ഡ്രൈവുകൾ സൃഷ്ടിക്കുന്നതിൽ രചയിതാവിന് അനുയോജ്യമായ അനുഭവമുണ്ട്, കൂടാതെ, സാധാരണ ആപ്റ്റ് ടെംപ്ലേറ്റ് തകർക്കാതിരിക്കാൻ, ഉബുണ്ടു 18.04 ടാർഗെറ്റ് സിസ്റ്റമായി തിരഞ്ഞെടുത്തു, അത് ഇതിനകം വേണ്ടത്ര സ്ഥിരതയുള്ളതാണ്, പക്ഷേ ഇപ്പോഴും 3 വർഷമുണ്ട്. ഭാവിയിൽ പിന്തുണ.

സൂചിപ്പിച്ച സിസ്റ്റത്തിൽ നമുക്ക് ആവശ്യമായ എല്ലാ ഹാർഡ്‌വെയർ ഡ്രൈവറുകളും ബോക്‌സിന് പുറത്ത് അടങ്ങിയിരിക്കുന്നു. ഞങ്ങൾക്ക് മൂന്നാം കക്ഷി സോഫ്റ്റ്‌വെയറോ ഡ്രൈവറുകളോ ആവശ്യമില്ല.

ഇൻസ്റ്റാളേഷനായുള്ള തയ്യാറെടുപ്പ്

സിസ്റ്റം ഇൻസ്റ്റാൾ ചെയ്യാൻ നമുക്ക് ഉബുണ്ടു ഡെസ്ക്ടോപ്പ് ഇമേജ് ആവശ്യമാണ്. സെർവർ സിസ്റ്റത്തിന് ഏതെങ്കിലും തരത്തിലുള്ള ഊർജ്ജസ്വലമായ ഇൻസ്റ്റാളർ ഉണ്ട്, അത് UEFI സിസ്റ്റം പാർട്ടീഷൻ ഡിസ്കുകളിൽ ഒന്നിലേക്ക് തള്ളിക്കൊണ്ട് പ്രവർത്തനരഹിതമാക്കാൻ കഴിയാത്ത അമിതമായ സ്വാതന്ത്ര്യം കാണിക്കുന്നു, ഇത് എല്ലാ സൗന്ദര്യവും നശിപ്പിക്കുന്നു. അതനുസരിച്ച്, ഇത് UEFI മോഡിൽ മാത്രമേ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ളൂ. ഓപ്‌ഷനുകളൊന്നും നൽകുന്നില്ല.

ഇതിൽ ഞങ്ങൾ സന്തുഷ്ടരല്ല.

എന്തുകൊണ്ട്?നിർഭാഗ്യവശാൽ, UEFI ബൂട്ട് ബൂട്ട് സോഫ്റ്റ്‌വെയർ റെയിഡുമായി വളരെ മോശമായി പൊരുത്തപ്പെടുന്നില്ല, കാരണം... UEFI ESP പാർട്ടീഷനായി ആരും ഞങ്ങൾക്ക് റിസർവേഷനുകൾ വാഗ്ദാനം ചെയ്യുന്നില്ല. ഒരു യുഎസ്ബി പോർട്ടിൽ ഒരു ഫ്ലാഷ് ഡ്രൈവിൽ ESP പാർട്ടീഷൻ സ്ഥാപിക്കാൻ നിർദ്ദേശിക്കുന്ന പാചകക്കുറിപ്പുകൾ ഇന്റർനെറ്റിൽ ഉണ്ട്, എന്നാൽ ഇത് പരാജയത്തിന്റെ ഒരു പോയിന്റാണ്. ഈ പാർട്ടീഷൻ കാണുന്നതിൽ നിന്ന് UEFI BIOS-നെ തടയാത്ത, മെറ്റാഡാറ്റ പതിപ്പ് 1 ഉള്ള mdadm RAID 0.9 എന്ന സോഫ്റ്റ്‌വെയർ ഉപയോഗിക്കുന്ന പാചകക്കുറിപ്പുകൾ ഉണ്ട്, എന്നാൽ BIOS അല്ലെങ്കിൽ മറ്റൊരു ഹാർഡ്‌വെയർ OS ESP-ലേക്ക് എന്തെങ്കിലും എഴുതുകയും അത് മറ്റൊന്നുമായി സമന്വയിപ്പിക്കാൻ മറക്കുകയും ചെയ്യുന്ന സന്തോഷ നിമിഷം വരെ ഇത് നിലനിൽക്കുന്നു. കണ്ണാടികൾ.

കൂടാതെ, UEFI ബൂട്ട് NVRAM-നെ ആശ്രയിച്ചിരിക്കുന്നു, അത് ഡിസ്കുകൾക്കൊപ്പം പുതിയ സിസ്റ്റത്തിലേക്ക് നീങ്ങില്ല, കാരണം മദർബോർഡിന്റെ ഭാഗമാണ്.

അതിനാൽ, ഞങ്ങൾ ഒരു പുതിയ ചക്രം പുനർനിർമ്മിക്കില്ല. UEFI-അനുയോജ്യമായ സിസ്റ്റങ്ങളിൽ CSM എന്ന അഭിമാനകരമായ പേര് വഹിക്കുന്ന, ഇപ്പോൾ ലെഗസി/ബയോസ് ബൂട്ട് എന്ന് വിളിക്കപ്പെടുന്ന ഒരു റെഡിമെയ്ഡ്, ടൈം-ടെസ്റ്റ് ചെയ്ത മുത്തച്ഛന്റെ ബൈക്ക് ഞങ്ങളുടെ പക്കലുണ്ട്. ഞങ്ങൾ അത് ഷെൽഫിൽ നിന്ന് എടുത്ത് ലൂബ്രിക്കേറ്റ് ചെയ്ത് ടയറുകൾ പമ്പ് ചെയ്ത് നനഞ്ഞ തുണി ഉപയോഗിച്ച് തുടയ്ക്കും.

ലെഗസി ബൂട്ട്ലോഡർ ഉപയോഗിച്ച് ഉബുണ്ടുവിന്റെ ഡെസ്ക്ടോപ്പ് പതിപ്പും ശരിയായി ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയില്ല, എന്നാൽ ഇവിടെ, അവർ പറയുന്നതുപോലെ, കുറഞ്ഞത് ഓപ്ഷനുകൾ ഉണ്ട്.

അതിനാൽ, ഞങ്ങൾ ഹാർഡ്‌വെയർ ശേഖരിക്കുകയും ഉബുണ്ടു ലൈവ് ബൂട്ടബിൾ ഫ്ലാഷ് ഡ്രൈവിൽ നിന്ന് സിസ്റ്റം ലോഡ് ചെയ്യുകയും ചെയ്യുന്നു. ഞങ്ങൾക്ക് പാക്കേജുകൾ ഡൗൺലോഡ് ചെയ്യേണ്ടതുണ്ട്, അതിനാൽ നിങ്ങൾക്കായി പ്രവർത്തിക്കുന്ന നെറ്റ്‌വർക്ക് ഞങ്ങൾ സജ്ജീകരിക്കും. ഇത് പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, നിങ്ങൾക്ക് ആവശ്യമായ പാക്കേജുകൾ മുൻകൂട്ടി ഒരു ഫ്ലാഷ് ഡ്രൈവിലേക്ക് ലോഡ് ചെയ്യാം.

ഞങ്ങൾ ഡെസ്‌ക്‌ടോപ്പ് പരിതസ്ഥിതിയിലേക്ക് പോയി, ടെർമിനൽ എമുലേറ്റർ സമാരംഭിക്കുക, തുടർന്ന് ഞങ്ങൾ പോകുന്നു:

#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-ൽ സംഭരിക്കുന്നില്ല.
സിസ്റ്റം ഓഫ് ചെയ്യാതെ തന്നെ സ്‌നാപ്പ്ഷോട്ടുകൾ സൃഷ്‌ടിക്കാൻ മാത്രമേ ഈ എഫ്എസ് ഉപയോഗിക്കൂ, തുടർന്ന് ഈ സ്‌നാപ്പ്‌ഷോട്ടുകൾ അയയ്ക്കുക/സ്വീകരിക്കുക ഉപയോഗിച്ച് ഒരു ബാക്കപ്പ് ഡിസ്‌കിലേക്ക് മാറ്റുക.

കൂടാതെ, രചയിതാവ് സാധാരണയായി ഹാർഡ്‌വെയറിൽ ഒരു മിനിമം സോഫ്‌റ്റ്‌വെയർ സൂക്ഷിക്കാനും IOMMU വഴി KVM-ലേക്ക് GPU-കളും PCI-USB ഹോസ്റ്റ് കൺട്രോളറുകളും ഫോർവേഡ് ചെയ്യുന്നത് പോലെയുള്ള കാര്യങ്ങൾ ഉപയോഗിച്ച് വെർച്വൽ മെഷീനുകളിൽ മറ്റെല്ലാ സോഫ്റ്റ്‌വെയറുകളും പ്രവർത്തിപ്പിക്കാനും താൽപ്പര്യപ്പെടുന്നു.

ഡാറ്റ സംഭരണം, വിർച്ച്വലൈസേഷൻ, ബാക്കപ്പ് എന്നിവ മാത്രമാണ് ഹാർഡ്‌വെയറിൽ അവശേഷിക്കുന്നത്.

നിങ്ങൾ 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 ഈ ഡ്രൈവുകൾ കാണുന്നില്ല. അതിനാൽ, അവർ പൂർണ്ണമായും സോഫ്റ്റ്വെയർ റെയിഡിലേക്ക് പോകും. ഞങ്ങൾ അവിടെ വിഭാഗങ്ങൾ പോലും സൃഷ്ടിക്കില്ല. നിങ്ങൾക്ക് "കാനോൻ" അല്ലെങ്കിൽ "പ്രിൻസിപ്പലി" പിന്തുടരണമെങ്കിൽ, 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 പാർട്ടീഷനും തുടക്കത്തിൽ തന്നെ ആയിരിക്കണം എന്നതാണ് പ്രധാന കാര്യം. ജിപിടി ലെഗസി/ബയോസ് ഡ്രൈവുകളിൽ നിന്ന് ബൂട്ട് ചെയ്യാൻ പോലും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

എന്നാൽ ഇത് ഞങ്ങളുടെ കാര്യമല്ല.

ഇവിടെ നമ്മൾ രണ്ട് വിഭാഗങ്ങൾ സൃഷ്ടിക്കും. ആദ്യത്തേത് 1 GB വലുപ്പമുള്ളതും RAID 1 /boot-ന് ഉപയോഗിക്കുന്നതുമാണ്.

രണ്ടാമത്തേത് RAID 6-ന് ഉപയോഗിക്കും കൂടാതെ ഡ്രൈവിന്റെ അവസാനത്തിൽ അനുവദിക്കാത്ത ഒരു ചെറിയ ഏരിയ ഒഴികെ ബാക്കിയുള്ള എല്ലാ സ്ഥലവും എടുക്കും.

എന്താണ് ഈ അടയാളപ്പെടുത്താത്ത പ്രദേശം?നെറ്റ്‌വർക്കിലെ സ്രോതസ്സുകൾ അനുസരിച്ച്, ഞങ്ങളുടെ SATA SSD-കൾക്ക് 6 മുതൽ 78 ജിഗാബൈറ്റ് വരെ വലുപ്പമുള്ള ചലനാത്മകമായി വികസിപ്പിക്കാവുന്ന SLC കാഷെ ഉണ്ട്. ഡ്രൈവിന്റെ ഡാറ്റ ഷീറ്റിലെ "ജിഗാബൈറ്റ്", "ജിബിബൈറ്റ്" എന്നിവ തമ്മിലുള്ള വ്യത്യാസം കാരണം നമുക്ക് 6 ജിഗാബൈറ്റ് "സൗജന്യമായി" ലഭിക്കും. ശേഷിക്കുന്ന 72 ജിഗാബൈറ്റുകൾ ഉപയോഗിക്കാത്ത സ്ഥലത്ത് നിന്ന് അനുവദിച്ചിരിക്കുന്നു.

ഇവിടെ നമുക്ക് ഒരു SLC കാഷെ ഉണ്ടെന്ന് ശ്രദ്ധിക്കേണ്ടതാണ്, കൂടാതെ സ്ഥലം 4 ബിറ്റ് MLC മോഡിൽ ഉൾക്കൊള്ളുന്നു. ഞങ്ങളെ സംബന്ധിച്ചിടത്തോളം ഫലപ്രദമായി അർത്ഥമാക്കുന്നത് ഓരോ 4 ജിഗാബൈറ്റ് ശൂന്യമായ ഇടത്തിനും ഞങ്ങൾക്ക് 1 ജിഗാബൈറ്റ് SLC കാഷെ മാത്രമേ ലഭിക്കൂ എന്നാണ്.

72 ജിഗാബൈറ്റിനെ 4 കൊണ്ട് ഗുണിച്ചാൽ 288 ജിഗാബൈറ്റ് നേടൂ. SLC കാഷെ പൂർണ്ണമായി ഉപയോഗിക്കുന്നതിന് ഡ്രൈവുകളെ അനുവദിക്കുന്നതിനായി ഞങ്ങൾ അടയാളപ്പെടുത്താത്ത സ്വതന്ത്ര ഇടമാണിത്.

അങ്ങനെ, മൊത്തം ആറ് ഡ്രൈവുകളിൽ നിന്ന് 312 ജിഗാബൈറ്റ് എസ്എൽസി കാഷെ നമുക്ക് ഫലപ്രദമായി ലഭിക്കും. എല്ലാ ഡ്രൈവുകളിലും, 2 എണ്ണം ആവർത്തനത്തിനായി RAID-ൽ ഉപയോഗിക്കും.

ഈ കാഷെയുടെ അളവ് യഥാർത്ഥ ജീവിതത്തിൽ വളരെ അപൂർവ്വമായി ഒരു എഴുത്ത് കാഷെയിലേക്ക് പോകാത്ത ഒരു സാഹചര്യം നേരിടാൻ നമ്മെ അനുവദിക്കും. ക്യുഎൽസി മെമ്മറിയുടെ ഏറ്റവും ദുഖകരമായ പോരായ്മയ്ക്ക് ഇത് വളരെ നന്നായി നഷ്ടപരിഹാരം നൽകുന്നു - കാഷെ മറികടന്ന് ഡാറ്റ എഴുതുമ്പോൾ വളരെ കുറഞ്ഞ റൈറ്റ് വേഗത. നിങ്ങളുടെ ലോഡുകൾ ഇതുമായി പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, ഡാറ്റാ ഷീറ്റിൽ നിന്നുള്ള ടിബിഡബ്ല്യു കണക്കിലെടുത്ത് അത്തരം ഒരു ലോഡിന് കീഴിൽ നിങ്ങളുടെ എസ്എസ്ഡി എത്രത്തോളം നിലനിൽക്കുമെന്ന് നിങ്ങൾ നന്നായി ചിന്തിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു.

#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 അറേകളിൽ “ഇനിഷ്യലൈസ്” ചെയ്യാൻ ഞങ്ങൾ TRIM/DISCARD ഉപയോഗിക്കുന്നു.

SSD അറേകൾക്കായി, RAID 1 ഡിസ്‌കാർഡ് ബോക്‌സിന് പുറത്ത് പിന്തുണയ്‌ക്കുന്നു.

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

എന്തിനാ ഇത്ര വലുത്...?ചങ്ക്-വലുപ്പം വർധിപ്പിക്കുന്നത് ഭാഗങ്ങളിൽ ക്രമരഹിതമായ വായനയുടെ വേഗതയിൽ നല്ല സ്വാധീനം ചെലുത്തുന്നു. ഇത് സംഭവിക്കുന്നത് ഉചിതമായ വലിപ്പമോ അതിൽ കുറവോ ഉള്ള ഒരു പ്രവർത്തനം ഒരു ഉപകരണത്തിൽ പൂർണ്ണമായും പൂർത്തിയാക്കാൻ കഴിയും. അതിനാൽ, എല്ലാ ഉപകരണങ്ങളിൽ നിന്നുമുള്ള IOPS സംഗ്രഹിച്ചിരിക്കുന്നു. സ്ഥിതിവിവരക്കണക്കുകൾ പ്രകാരം, IO യുടെ 99% 512K കവിയുന്നില്ല.

ഓരോ എഴുത്തിനും RAID 6 IOPS എപ്പോഴും ഒരു ഡ്രൈവിന്റെ IOPS-നേക്കാൾ കുറവോ തുല്യമോ. ഒരു ക്രമരഹിതമായി വായിക്കുമ്പോൾ, IOPS ഒരു ഡ്രൈവിനേക്കാൾ പലമടങ്ങ് കൂടുതലാകുമ്പോൾ, ഇവിടെ ബ്ലോക്ക് വലുപ്പത്തിന് പ്രധാന പ്രാധാന്യമുണ്ട്.
RAID 6 ബൈ-ഡിസൈനിലെ മോശമായ ഒരു പാരാമീറ്റർ ഒപ്റ്റിമൈസ് ചെയ്യാൻ ശ്രമിക്കുന്നതിന്റെ അർത്ഥം രചയിതാവ് കാണുന്നില്ല, പകരം RAID 6 എന്താണ് മികച്ചതെന്ന് ഒപ്റ്റിമൈസ് ചെയ്യുന്നു.
RAID 6-ന്റെ മോശം റാൻഡം റൈറ്റ് ഒരു NVMe കാഷെയും നേർത്ത പ്രൊവിഷനിംഗ് തന്ത്രങ്ങളും ഉപയോഗിച്ച് ഞങ്ങൾ നഷ്ടപരിഹാരം നൽകും.

റെയ്ഡ് 6-നായി ഞങ്ങൾ ഇതുവരെ ഡിസ്കാർഡ് പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല. അതിനാൽ ഞങ്ങൾ ഈ അറേ ഇപ്പോൾ "ആരംഭിക്കുന്നില്ല". 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 ആണ്.
എന്നിരുന്നാലും, സ്വാപ്പ്, മെറ്റാഡാറ്റ, എൽവിഎം-കാഷെ, എൽവിഎം-തിൻ മെറ്റാഡാറ്റ എന്നിവ പോലുള്ള മറ്റ് ആവശ്യങ്ങൾക്കായി ഞങ്ങൾക്ക് ഈ ഫാസ്റ്റ് അറേ ആവശ്യമാണ്, അതിനാൽ ഞങ്ങൾ ഈ അറേയിൽ ഒരു എൽവിഎം വിജി സൃഷ്ടിക്കും.

#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), - മൗണ്ട് പോയിന്റ് / (റൂട്ട്), FS - BTRFS
• /dev/root/swap (aka /dev/mapper/root-swap), - സ്വാപ്പ് പാർട്ടീഷനായി ഉപയോഗിക്കുക
• /dev/sda-ൽ ബൂട്ട്ലോഡർ ഇൻസ്റ്റാൾ ചെയ്യുക

നിങ്ങൾ റൂട്ട് ഫയൽ സിസ്റ്റമായി BTRFS തിരഞ്ഞെടുക്കുമ്പോൾ, ഇൻസ്റ്റാളർ സ്വയമേവ "@" എന്ന പേരിൽ / (root), "@home" എന്ന പേരിൽ രണ്ട് 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-യ്ക്ക് പ്രത്യേകിച്ച് സത്യമാണ്. (റേഡിയേറ്ററിനെ കുറിച്ച് ഓർക്കുന്നുണ്ടോ? ഞാൻ തമാശ പറഞ്ഞതല്ല.)
• എപിഎം വഴി സ്പിൻഡിൽ റൊട്ടേഷൻ (എച്ച്ഡിഡി) നിർത്തുന്നതിൽ നിന്ന് ഡിസ്കുകളെ നിരോധിക്കുക, ഡിസ്ക് കൺട്രോളറുകൾക്കുള്ള സ്ലീപ്പ് ടൈംഔട്ട് 7 മണിക്കൂറായി സജ്ജമാക്കുക. നിങ്ങളുടെ ഡ്രൈവുകൾക്ക് അത് ചെയ്യാൻ കഴിയുമെങ്കിൽ നിങ്ങൾക്ക് APM പൂർണ്ണമായും പ്രവർത്തനരഹിതമാക്കാം (-B 255). ഡിഫോൾട്ട് മൂല്യത്തിൽ, അഞ്ച് സെക്കൻഡിന് ശേഷം ഡ്രൈവുകൾ നിർത്തും. അപ്പോൾ OS ഡിസ്ക് കാഷെ പുനഃസജ്ജമാക്കാൻ ആഗ്രഹിക്കുന്നു, ഡിസ്കുകൾ വീണ്ടും കറങ്ങും, എല്ലാം വീണ്ടും ആരംഭിക്കും. ഡിസ്കുകൾക്ക് പരിമിതമായ പരമാവധി സ്പിൻഡിൽ റൊട്ടേഷനുകൾ ഉണ്ട്. അത്തരമൊരു ലളിതമായ സ്ഥിരസ്ഥിതി സൈക്കിളിന് കുറച്ച് വർഷത്തിനുള്ളിൽ നിങ്ങളുടെ ഡിസ്കുകളെ എളുപ്പത്തിൽ നശിപ്പിക്കാനാകും. എല്ലാ ഡിസ്കുകളും ഇതിൽ നിന്ന് കഷ്ടപ്പെടുന്നില്ല, എന്നാൽ ഞങ്ങളുടേത് "ലാപ്ടോപ്പ്" ആണ്, ഉചിതമായ സ്ഥിരസ്ഥിതി സജ്ജീകരണങ്ങൾ ഉള്ളതാണ്, ഇത് റെയ്ഡിനെ ഒരു മിനി-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 നാമങ്ങൾ ഉപയോഗിച്ച് തിരയും, കാരണം അവർ പാർട്ടീഷനുകളെ തികച്ചും അദ്വിതീയമായി തിരിച്ചറിയുന്നു.

എൽവിഎമ്മിനായി ഞങ്ങൾ UUID ഉപയോഗിക്കുന്നില്ല കാരണം എൽവിഎം വോള്യങ്ങളുടെ യുയുഐഡിയും അവയുടെ സ്നാപ്പ്ഷോട്ടുകളും സമാനമായിരിക്കും.മൗണ്ട് /dev/mapper/root-root.. രണ്ടുതവണ?അതെ. കൃത്യമായി. BTRFS-ന്റെ സവിശേഷത. ഈ ഫയൽ സിസ്റ്റം വ്യത്യസ്‌ത സബ്‌വോളുകൾ ഉപയോഗിച്ച് നിരവധി തവണ മൌണ്ട് ചെയ്യാവുന്നതാണ്.

ഇതേ സവിശേഷത കാരണം, സജീവമായ BTRFS വോള്യങ്ങളുടെ എൽവിഎം സ്നാപ്പ്ഷോട്ടുകൾ സൃഷ്ടിക്കരുതെന്ന് ഞാൻ ശുപാർശ ചെയ്യുന്നു. നിങ്ങൾ റീബൂട്ട് ചെയ്യുമ്പോൾ നിങ്ങൾക്ക് ഒരു അത്ഭുതം ഉണ്ടായേക്കാം.

നമുക്ക് 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% കൊണ്ട് എൽവിഎം നേർത്ത പൂളുകളുടെ യാന്ത്രിക വിപുലീകരണം ഞങ്ങൾ പ്രവർത്തനക്ഷമമാക്കി.

എൽവിഎം കാഷെക്കായി ഞങ്ങൾ കാഷെ ബ്ലോക്കുകളുടെ പരമാവധി എണ്ണം വർദ്ധിപ്പിച്ചു.

ഇതിൽ എൽവിഎം വോള്യങ്ങൾ (പിവി) തിരയുന്നതിൽ നിന്ന് ഞങ്ങൾ എൽവിഎമ്മിനെ തടഞ്ഞു:

• എൽവിഎം കാഷെ (സിഡാറ്റ) അടങ്ങിയ ഉപകരണങ്ങൾ
• കാഷെ മറികടന്ന് എൽവിഎം കാഷെ ഉപയോഗിച്ച് ഉപകരണങ്ങൾ കാഷെ ചെയ്‌തു ( _കോറിഗ്). ഈ സാഹചര്യത്തിൽ, കാഷെ ചെയ്‌ത ഉപകരണം തന്നെ ഇപ്പോഴും കാഷെയിലൂടെ സ്കാൻ ചെയ്യും (വെറും ).
• എൽവിഎം കാഷെ മെറ്റാഡാറ്റ (cmeta) അടങ്ങിയിരിക്കുന്ന ഉപകരണങ്ങൾ
• പേരുള്ള ചിത്രങ്ങളുള്ള വിജിയിലെ എല്ലാ ഉപകരണങ്ങളും. ഇവിടെ നമുക്ക് വെർച്വൽ മെഷീനുകളുടെ ഡിസ്ക് ഇമേജുകൾ ഉണ്ടാകും, കൂടാതെ അതിഥി OS-ന്റെ വോള്യങ്ങൾ സജീവമാക്കാൻ ഹോസ്റ്റിലെ എൽവിഎം ആവശ്യമില്ല.
• ബാക്കപ്പ് എന്ന പേരുള്ള VG-യിലെ എല്ലാ ഉപകരണങ്ങളും. ഇവിടെ നമുക്ക് വെർച്വൽ മെഷീൻ ഇമേജുകളുടെ ബാക്കപ്പ് പകർപ്പുകൾ ഉണ്ടാകും.
• "gpv" (അതിഥി ഫിസിക്കൽ വോളിയം) എന്ന് അവസാനിക്കുന്ന എല്ലാ ഉപകരണങ്ങളും

എൽവിഎം വിജിയിൽ ശൂന്യമായ ഇടം സൃഷ്‌ടിക്കുമ്പോൾ ഞങ്ങൾ ഡിസ്‌കാർഡ് പിന്തുണ പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ട്. ശ്രദ്ധാലുവായിരിക്കുക. ഇത് എസ്എസ്ഡിയിൽ എൽവികൾ ഇല്ലാതാക്കുന്നത് വളരെ സമയമെടുക്കും. ഇത് പ്രത്യേകിച്ചും 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 ചേർത്തത്..?അമിതമായ സ്വാതന്ത്ര്യത്തിനും കളിയായ കൈകൾക്കും.

റെയിഡുകളിലൊന്ന് തരംതാഴ്ന്ന നിലയിലാണെങ്കിൽ അത് ശരിയായി പ്രവർത്തിക്കില്ല. ഈ ഹാർഡ്‌വെയറിൽ പ്രവർത്തിക്കുന്ന വെർച്വൽ മെഷീനുകളിൽ ഉപയോഗിക്കുന്ന പാർട്ടീഷനുകളിൽ OS തിരയാൻ ഇത് ശ്രമിക്കുന്നു.

നിങ്ങൾക്ക് വേണമെങ്കിൽ, നിങ്ങൾക്ക് അത് ഉപേക്ഷിക്കാം, എന്നാൽ മുകളിൽ പറഞ്ഞവയെല്ലാം മനസ്സിൽ വയ്ക്കുക. വികൃതി കൈകളിൽ നിന്ന് മുക്തി നേടാനുള്ള പാചകക്കുറിപ്പുകൾ ഓൺലൈനിൽ തിരയാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു.

ഇതോടെ ഞങ്ങൾ പ്രാഥമിക ഇൻസ്റ്റാളേഷൻ പൂർത്തിയാക്കി. പുതുതായി ഇൻസ്റ്റാൾ ചെയ്ത OS-ലേക്ക് റീബൂട്ട് ചെയ്യാനുള്ള സമയമാണിത്. ബൂട്ട് ചെയ്യാവുന്ന ലൈവ് സിഡി/യുഎസ്ബി നീക്കം ചെയ്യാൻ മറക്കരുത്.

#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 ഉണ്ട്. എന്തുകൊണ്ട് എല്ലാം ഒരു വിജിയിൽ ചേർക്കരുത്?

ഒരു വിജിയിൽ നിരവധി പിവികൾ ഉണ്ടെങ്കിൽ, വിജി ശരിയായി സജീവമാകണമെങ്കിൽ, എല്ലാ പിവികളും ഉണ്ടായിരിക്കണം (ഓൺലൈൻ). ഒഴിവാക്കൽ LVM RAID ആണ്, അത് ഞങ്ങൾ മനപ്പൂർവ്വം ഉപയോഗിക്കാറില്ല.

RAID 6 അറേകളിൽ ഏതെങ്കിലും ഒരു പരാജയം (ഡാറ്റ നഷ്ടം വായിക്കുക) ഉണ്ടെങ്കിൽ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം സാധാരണ ബൂട്ട് ചെയ്യുകയും പ്രശ്നം പരിഹരിക്കാനുള്ള അവസരം നൽകുകയും ചെയ്യണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.

ഇത് ചെയ്യുന്നതിന്, അമൂർത്തീകരണത്തിന്റെ ആദ്യ തലത്തിൽ ഞങ്ങൾ ഓരോ തരം ഫിസിക്കൽ "മീഡിയ" യും ഒരു പ്രത്യേക വിജിയിലേക്ക് വേർതിരിച്ചെടുക്കും.

ശാസ്ത്രീയമായി പറഞ്ഞാൽ, വ്യത്യസ്‌ത റെയ്‌ഡ് അറേകൾ വ്യത്യസ്‌ത “വിശ്വാസ്യത ഡൊമെയ്‌നുകളിൽ” പെടുന്നു. അവരെ ഒരു VG-യിൽ ഒതുക്കിക്കൊണ്ട് നിങ്ങൾ അവർക്ക് ഒരു അധിക പരാജയ പോയിന്റ് സൃഷ്ടിക്കരുത്.

"ഹാർഡ്‌വെയർ" തലത്തിലുള്ള എൽവിഎമ്മിന്റെ സാന്നിദ്ധ്യം, വ്യത്യസ്ത റെയ്‌ഡ് അറേകളുടെ കഷണങ്ങൾ വ്യത്യസ്ത രീതികളിൽ സംയോജിപ്പിച്ച് ഏകപക്ഷീയമായി മുറിക്കാൻ ഞങ്ങളെ അനുവദിക്കും. ഉദാഹരണത്തിന് - ഓടുക അതേ സമയം bcache + LVM thin, bcache + BTRFS, LVM കാഷെ + LVM നേർത്ത, കാഷെകളുള്ള ഒരു സങ്കീർണ്ണമായ ZFS കോൺഫിഗറേഷൻ, അല്ലെങ്കിൽ എല്ലാം താരതമ്യം ചെയ്യാൻ ശ്രമിച്ചുനോക്കാൻ മറ്റേതെങ്കിലും നരക മിശ്രിതം.

“ഹാർഡ്‌വെയർ” തലത്തിൽ, നല്ല പഴയ “കട്ടിയുള്ള” എൽവിഎം വോള്യങ്ങളല്ലാതെ മറ്റൊന്നും ഞങ്ങൾ ഉപയോഗിക്കില്ല. ഈ നിയമത്തിന് ഒരു അപവാദം ബാക്കപ്പ് പാർട്ടീഷൻ ആയിരിക്കാം.

ഈ നിമിഷം വരെ, പല വായനക്കാരും നെസ്റ്റിംഗ് പാവയെക്കുറിച്ച് എന്തെങ്കിലും സംശയിക്കാൻ തുടങ്ങിയിട്ടുണ്ടെന്ന് ഞാൻ കരുതുന്നു.

SATA HDD-യിൽ LVM

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

വീണ്ടും പുതിയ വിജി..?ഡാറ്റ ബാക്കപ്പിനായി ഞങ്ങൾ ഉപയോഗിക്കുന്ന ഡിസ്ക് അറേ പരാജയപ്പെടുകയാണെങ്കിൽ, ഞങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം സാധാരണ രീതിയിൽ പ്രവർത്തിക്കുന്നത് തുടരും, അതേ സമയം നോൺ-ബാക്കപ്പ് ഡാറ്റയിലേക്കുള്ള ആക്സസ് നിലനിർത്തുന്നത് ഞങ്ങൾ ശരിക്കും ആഗ്രഹിക്കുന്നു. അതിനാൽ, വിജി ആക്ടിവേഷൻ പ്രശ്നങ്ങൾ ഒഴിവാക്കാൻ, ഞങ്ങൾ ഒരു പ്രത്യേക വിജി സൃഷ്ടിക്കുന്നു.

LVM കാഷെ സജ്ജീകരിക്കുന്നു

ഒരു കാഷിംഗ് ഉപകരണമായി ഉപയോഗിക്കുന്നതിന് NVMe RAID 1-ൽ ഒരു LV സൃഷ്ടിക്കാം.

#lvcreate -L 70871154688B --name cache root

എന്തിനാ ഇത്ര കുറവ്...?ഞങ്ങളുടെ NVMe SSD-കളിലും ഒരു SLC കാഷെ ഉണ്ട് എന്നതാണ് വസ്തുത. 4 ജിഗാബൈറ്റ് "ഫ്രീ", 18 ജിഗാബൈറ്റ് ഡൈനാമിക് എന്നിവ 3-ബിറ്റ് എംഎൽസിയിൽ ഉള്ള സ്വതന്ത്ര ഇടം കാരണം. ഈ കാഷെ തീർന്നുകഴിഞ്ഞാൽ, NVMe SSD-കൾ കാഷെയുള്ള ഞങ്ങളുടെ SATA SSD-യെക്കാൾ വേഗതയുള്ളതായിരിക്കില്ല. യഥാർത്ഥത്തിൽ, ഇക്കാരണത്താൽ, NVMe ഡ്രൈവിന്റെ SLC കാഷെയുടെ ഇരട്ടിയേക്കാൾ വലുതായി LVM കാഷെ പാർട്ടീഷൻ ഉണ്ടാക്കുന്നതിൽ അർത്ഥമില്ല. ഉപയോഗിച്ച NVMe ഡ്രൈവുകൾക്കായി, 32-64 ജിഗാബൈറ്റ് കാഷെ ഉണ്ടാക്കുന്നത് ന്യായമാണെന്ന് രചയിതാവ് കരുതുന്നു.

64 ജിഗാബൈറ്റ് കാഷെ, കാഷെ മെറ്റാഡാറ്റ, മെറ്റാഡാറ്റ ബാക്കപ്പ് എന്നിവ സംഘടിപ്പിക്കുന്നതിന് നൽകിയിരിക്കുന്ന പാർട്ടീഷൻ വലുപ്പം ആവശ്യമാണ്.

കൂടാതെ, ഒരു വൃത്തികെട്ട സിസ്റ്റം ഷട്ട്ഡൗണിന് ശേഷം, എൽവിഎം മുഴുവൻ കാഷെയും വൃത്തികെട്ടതായി അടയാളപ്പെടുത്തുകയും വീണ്ടും സമന്വയിപ്പിക്കുകയും ചെയ്യും. മാത്രമല്ല, സിസ്റ്റം വീണ്ടും റീബൂട്ട് ചെയ്യുന്നതുവരെ ഈ ഉപകരണത്തിൽ 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

ഇത് ഓൺലൈനിലാണ് ചെയ്യുന്നത്. എൽവിഎം കാഷെ ഡിസ്കിലേക്ക് സമന്വയിപ്പിക്കുകയും അത് നീക്കം ചെയ്യുകയും cachedata_corig വീണ്ടും കാഷെഡാറ്റയിലേക്ക് പേരുമാറ്റുകയും ചെയ്യും.

എൽവിഎം തിൻ സജ്ജീകരിക്കുന്നു

എൽവിഎം നേർത്ത മെറ്റാഡാറ്റയ്ക്ക് എത്ര സ്ഥലം വേണമെന്ന് നമുക്ക് ഏകദേശം കണക്കാക്കാം:

#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

എന്തിനുവേണ്ടി..?ഇവിടെ ചോദ്യം ഉയർന്നേക്കാം: എൽവിഎം നേർത്ത മെറ്റാഡാറ്റ ഇപ്പോഴും എൻവിഎംയിൽ കാഷെ ചെയ്‌തിരിക്കുകയും വേഗത്തിൽ പ്രവർത്തിക്കുകയും ചെയ്‌താൽ വെവ്വേറെ സ്ഥാപിക്കുന്നത് എന്തുകൊണ്ട്.

വേഗത ഇവിടെ പ്രധാനമാണെങ്കിലും, അത് പ്രധാന കാരണത്തിൽ നിന്ന് വളരെ അകലെയാണ്. കാഷെ പരാജയത്തിൻ്റെ ഒരു പോയിൻ്റാണ് എന്നതാണ് കാര്യം. ഇതിന് എന്തെങ്കിലും സംഭവിക്കാം, കൂടാതെ എൽവിഎം നേർത്ത മെറ്റാഡാറ്റ കാഷെ ചെയ്താൽ, അത് എല്ലാം പൂർണ്ണമായും നഷ്‌ടപ്പെടാൻ ഇടയാക്കും. പൂർണ്ണമായ മെറ്റാഡാറ്റ ഇല്ലാതെ, നേർത്ത വോള്യങ്ങൾ കൂട്ടിച്ചേർക്കുന്നത് മിക്കവാറും അസാധ്യമായിരിക്കും.

കാഷെ ചെയ്യാത്തതും എന്നാൽ വേഗതയേറിയതുമായ വോളിയത്തിലേക്ക് മെറ്റാഡാറ്റ നീക്കുന്നതിലൂടെ, കാഷെ നഷ്‌ടമോ അഴിമതിയോ സംഭവിക്കുമ്പോൾ മെറ്റാഡാറ്റയുടെ സുരക്ഷ ഞങ്ങൾ ഉറപ്പ് നൽകുന്നു. ഈ സാഹചര്യത്തിൽ, കാഷെ നഷ്ടം മൂലമുണ്ടാകുന്ന എല്ലാ നാശനഷ്ടങ്ങളും നേർത്ത വോള്യങ്ങളിൽ പ്രാദേശികവൽക്കരിക്കപ്പെടും, ഇത് മാഗ്നിറ്റ്യൂഡ് ഓർഡറുകൾ പ്രകാരം വീണ്ടെടുക്കൽ നടപടിക്രമം ലളിതമാക്കും. ഉയർന്ന സംഭാവ്യതയോടെ, എഫ്എസ് ലോഗുകൾ ഉപയോഗിച്ച് ഈ കേടുപാടുകൾ പുനഃസ്ഥാപിക്കും.

കൂടാതെ, ഒരു നേർത്ത വോള്യത്തിന്റെ ഒരു സ്‌നാപ്പ്‌ഷോട്ട് മുമ്പ് എടുത്തിരുന്നുവെങ്കിൽ, അതിനുശേഷം കാഷെ ഒരു തവണയെങ്കിലും പൂർണ്ണമായി സമന്വയിപ്പിച്ചിട്ടുണ്ടെങ്കിൽ, എൽവിഎം തിന്നിന്റെ ആന്തരിക രൂപകൽപ്പന കാരണം, കാഷെ നഷ്‌ടപ്പെടുമ്പോൾ സ്‌നാപ്പ്ഷോട്ടിന്റെ സമഗ്രത ഉറപ്പുനൽകും. .

നമുക്ക് ഒരു പുതിയ 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
എന്തുകൊണ്ട് -Z വൈഈ മോഡ് യഥാർത്ഥത്തിൽ ഉദ്ദേശിച്ചതിന് പുറമേ - സ്ഥലം പുനർവിതരണം ചെയ്യുമ്പോൾ ഒരു വെർച്വൽ മെഷീനിൽ നിന്നുള്ള ഡാറ്റ മറ്റൊരു വെർച്വൽ മെഷീനിലേക്ക് ചോരുന്നത് തടയാൻ - 64k-ൽ താഴെയുള്ള ബ്ലോക്കുകളിൽ ക്രമരഹിതമായ എഴുത്തിന്റെ വേഗത വർദ്ധിപ്പിക്കുന്നതിന് സീറോയിംഗ് അധികമായി ഉപയോഗിക്കുന്നു. നേരിയ വോളിയത്തിന്റെ മുമ്പ് അനുവദിച്ചിട്ടില്ലാത്ത ഒരു ഏരിയയിലേക്ക് 64k-ൽ താഴെയുള്ള ഏതൊരു എഴുത്തും കാഷെയിൽ 64K എഡ്ജ്-അലൈൻ ആയി മാറും. കാഷെ ചെയ്ത ഉപകരണത്തെ മറികടന്ന് കാഷെ വഴി പ്രവർത്തനം പൂർണ്ണമായും നടത്താൻ ഇത് അനുവദിക്കും.

നമുക്ക് എൽവികളെ അനുബന്ധ പിവികളിലേക്ക് നീക്കാം:

#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 ജിഗാബൈറ്റ് എസ്എസ്ഡി റിസോഴ്സ് വരെ കഴിക്കാം.

എഴുത്തും വായനയും കലർന്നോ?അതെ. വായനയും എഴുത്തും പരീക്ഷകൾ വെവ്വേറെ നടത്തുന്നതിൽ അർത്ഥമുണ്ട്. കൂടാതെ, എല്ലാ കാഷെകളും സമന്വയിപ്പിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുന്നത് യുക്തിസഹമാണ്, അതിനാൽ മുമ്പ് തയ്യാറാക്കിയ ഒരു എഴുത്ത് വായനയെ ബാധിക്കില്ല.

കാഷെയും നേർത്ത വോളിയവും നിറയുമ്പോൾ ആദ്യ ലോഞ്ചിലും തുടർന്നുള്ളവയിലും ഫലങ്ങളിൽ വലിയ വ്യത്യാസമുണ്ടാകും, കൂടാതെ അവസാന ലോഞ്ച് സമയത്ത് പൂരിപ്പിച്ച കാഷെകൾ സമന്വയിപ്പിക്കാൻ സിസ്റ്റത്തിന് കഴിഞ്ഞോ എന്നതിനെ ആശ്രയിച്ചിരിക്കും.

മറ്റ് കാര്യങ്ങളിൽ, ഒരു സ്‌നാപ്പ്ഷോട്ട് എടുത്ത ഒരു പൂർണ്ണ നേർത്ത വോള്യത്തിൽ വേഗത അളക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു. ആദ്യ സ്‌നാപ്പ്‌ഷോട്ട് സൃഷ്‌ടിച്ച ഉടൻ തന്നെ ക്രമരഹിതമായ എഴുത്തുകൾ എങ്ങനെ കുത്തനെ ത്വരിതപ്പെടുത്തുന്നുവെന്ന് നിരീക്ഷിക്കാൻ രചയിതാവിന് അവസരം ലഭിച്ചു, പ്രത്യേകിച്ചും കാഷെ ഇതുവരെ പൂർണ്ണമായും നിറഞ്ഞിട്ടില്ലെങ്കിൽ. കോപ്പി-ഓൺ-റൈറ്റ് റൈറ്റ് സെമാന്റിക്‌സ്, കാഷെയുടെയും നേർത്ത വോളിയം ബ്ലോക്കുകളുടെയും അലൈൻമെന്റ്, കൂടാതെ റെയ്‌ഡ് 6-ലേക്കുള്ള റാൻഡം റൈറ്റ്, റെയ്‌ഡ് 6-ൽ നിന്ന് റാൻഡം റീഡായി മാറുകയും തുടർന്ന് കാഷെയിലേക്കുള്ള ഒരു റൈറ്റ് എന്നിവ കാരണം ഇത് സംഭവിക്കുന്നു. ഞങ്ങളുടെ കോൺഫിഗറേഷനിൽ, RAID 6-ൽ നിന്നുള്ള റാൻഡം റീഡിംഗ് റൈറ്റിനെക്കാൾ 6 മടങ്ങ് (അറേയിലെ SATA SSD-കളുടെ എണ്ണം) വേഗത്തിലാണ്. കാരണം പശുവിനായുള്ള ബ്ലോക്കുകൾ ഒരു നേർത്ത കുളത്തിൽ നിന്ന് ക്രമാനുഗതമായി അനുവദിച്ചിരിക്കുന്നു, തുടർന്ന് റെക്കോർഡിംഗും മിക്കവാറും സീക്വൻഷ്യലായി മാറുന്നു.

ഈ രണ്ട് സവിശേഷതകളും നിങ്ങളുടെ നേട്ടത്തിനായി ഉപയോഗിക്കാം.

കാഷെ "കോഹറന്റ്" സ്നാപ്പ്ഷോട്ടുകൾ

കാഷെ കേടുപാടുകൾ/നഷ്‌ടമുണ്ടായാൽ ഡാറ്റാ നഷ്‌ടത്തിൻ്റെ അപകടസാധ്യത കുറയ്ക്കുന്നതിന്, ഈ സാഹചര്യത്തിൽ അവയുടെ സമഗ്രത ഉറപ്പുനൽകുന്നതിനായി സ്‌നാപ്പ്ഷോട്ടുകൾ തിരിക്കുന്ന രീതി അവതരിപ്പിക്കാൻ രചയിതാവ് നിർദ്ദേശിക്കുന്നു.

ആദ്യം, കാഷെ ചെയ്യാത്ത ഉപകരണത്തിൽ നേർത്ത വോളിയം മെറ്റാഡാറ്റ വസിക്കുന്നതിനാൽ, മെറ്റാഡാറ്റ സ്ഥിരതയുള്ളതും സാധ്യമായ നഷ്ടങ്ങൾ ഡാറ്റ ബ്ലോക്കുകളിൽ ഒറ്റപ്പെടുത്തുന്നതുമാണ്.

കാഷെ നഷ്‌ടപ്പെടുമ്പോൾ സ്‌നാപ്പ്‌ഷോട്ടുകൾക്കുള്ളിലെ ഡാറ്റയുടെ സമഗ്രത ഇനിപ്പറയുന്ന സ്‌നാപ്പ്‌ഷോട്ട് റൊട്ടേഷൻ സൈക്കിൾ ഉറപ്പ് നൽകുന്നു:

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% റൈറ്റ് ലോഡിൽ താഴെയായിരിക്കാൻ കഴിയില്ല. 100% റൈറ്റ് ലോഡിന് താഴെയുള്ള ഞങ്ങളുടെ NVMe SSD-കൾ റിസോഴ്‌സിനെ പൂർണ്ണമായും ഇല്ലാതാക്കും XXX - 3 ദിവസം. 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% സ്വയം പഠിപ്പിക്കുകയും "ഗൂഗിൾ" വഴിയുള്ള വികസനം പരിശീലിക്കുകയും ചെയ്യുന്നു, അതിനാൽ തന്റെ കൈകളിൽ നിന്ന് വരുന്ന ഭയാനകമായ കോഡ് ആരും ഉപയോഗിക്കരുതെന്ന് അദ്ദേഹം വിശ്വസിക്കുന്നു. വേറെ.

ഈ മേഖലയിലെ പ്രൊഫഷണലുകൾക്ക് ആവശ്യമെങ്കിൽ മുകളിൽ വിവരിച്ച എല്ലാ യുക്തികളും സ്വതന്ത്രമായി ചിത്രീകരിക്കാൻ കഴിയുമെന്ന് ഞാൻ കരുതുന്നു, കൂടാതെ, ഒരുപക്ഷേ, രചയിതാവ് ചെയ്യാൻ ശ്രമിച്ചതുപോലെ, ഒരു 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>

ഗസ്റ്റ് ഒഎസുകളിൽ നിന്നുള്ള ഇത്തരം ഡിസ്‌കാർഡുകൾ എൽവിഎം ശരിയായി പ്രോസസ്സ് ചെയ്യുന്നു, കാഷെയിലും നേർത്ത പൂളിലും ബ്ലോക്കുകൾ ശരിയായി സ്വതന്ത്രമാക്കപ്പെടുന്നു. ഞങ്ങളുടെ കാര്യത്തിൽ, അടുത്ത സ്നാപ്പ്ഷോട്ട് ഇല്ലാതാക്കുമ്പോൾ, ഇത് പ്രധാനമായും കാലതാമസം നേരിടുന്ന രീതിയിലാണ് സംഭവിക്കുന്നത്.

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


എൽവിഎം നേർത്ത ബാക്കപ്പ്

ബാക്കപ്പ് ഉപകരണത്തിൽ നമുക്ക് ഒരു നേർത്ത കുളം സൃഷ്ടിക്കാം:

#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

ആദ്യ വിക്ഷേപണം ദൈർഘ്യമേറിയതായിരിക്കും, കാരണം... ഉപയോഗിച്ച എല്ലാ സ്ഥലവും പകർത്തി നേർത്ത വോള്യങ്ങൾ പൂർണ്ണമായും സമന്വയിപ്പിക്കും. എൽവിഎം നേർത്ത മെറ്റാഡാറ്റയ്ക്ക് നന്ദി, ഏത് ബ്ലോക്കുകളാണ് യഥാർത്ഥത്തിൽ ഉപയോഗത്തിലുള്ളതെന്ന് ഞങ്ങൾക്കറിയാം, അതിനാൽ യഥാർത്ഥത്തിൽ ഉപയോഗിക്കുന്ന നേർത്ത വോളിയം ബ്ലോക്കുകൾ മാത്രമേ പകർത്തൂ.

എൽവിഎം നേർത്ത മെറ്റാഡാറ്റ വഴി ട്രാക്കിംഗ് മാറ്റുന്നതിന് നന്ദി, തുടർന്നുള്ള റണ്ണുകൾ ഡാറ്റ വർദ്ധിപ്പിച്ച് പകർത്തും.

എന്താണ് സംഭവിച്ചതെന്ന് നമുക്ക് നോക്കാം:

#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


കൂടുണ്ടാക്കുന്ന പാവകളുമായി ഇതിന് എന്ത് ബന്ധമുണ്ട്?

മിക്കവാറും, എൽവിഎം എൽവി ലോജിക്കൽ വോള്യങ്ങൾ മറ്റ് വിജികൾക്കുള്ള എൽവിഎം പിവി ഫിസിക്കൽ വോള്യങ്ങളാകാം. കൂടുകൂട്ടുന്ന പാവകളെപ്പോലെ എൽവിഎം ആവർത്തനപരമാകാം. ഇത് എൽവിഎം എക്സ്ട്രീം ഫ്ലെക്സിബിലിറ്റി നൽകുന്നു.

പി.എസ്

അടുത്ത ലേഖനത്തിൽ, ഹോം ഡെസ്‌ക്‌ടോപ്പുകൾ, ഹോം ഇൻറർനെറ്റ്, P2P നെറ്റ്‌വർക്കുകൾ എന്നിവ ഉപയോഗിച്ച് നിരവധി ഭൂഖണ്ഡങ്ങളിൽ ആവർത്തനത്തോടെ ജിയോ-ഡിസ്ട്രിബ്യൂട്ടഡ് സ്റ്റോറേജ്/വിഎം ക്ലസ്റ്റർ സൃഷ്ടിക്കുന്നതിനുള്ള അടിസ്ഥാനമായി സമാനമായ നിരവധി മൊബൈൽ സ്റ്റോറേജ് സിസ്റ്റങ്ങൾ/കെവിഎം ഉപയോഗിക്കാൻ ഞങ്ങൾ ശ്രമിക്കും.

അവലംബം: www.habr.com