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

പകലിന്റെ സമയം.
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 ബേകളിലെ സ്ലൈഡുകളിൽ സൗകര്യപ്രദമായി സ്ഥിതിചെയ്യുന്നു.

ശരി, തീർച്ചയായും, വ്യത്യസ്ത SSD കാഷിംഗ് രീതികൾ പരീക്ഷിച്ചതിന് Linux.

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

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

മുമ്പ്, ഹാർഡ്‌വെയർ ഇൻസ്റ്റാൾ ചെയ്തിരുന്നു Debian 8 ജെസ്സി, ഇത് EOL ന് അടുത്താണ്. മുകളിൽ പറഞ്ഞ LVM-മായി ജോടിയാക്കിയ HDD-കൾ ഉപയോഗിച്ചാണ് ഒരു RAID 6 സൃഷ്ടിച്ചത്. അത് പ്രവർത്തിച്ചുകൊണ്ടിരുന്നു വെർച്വൽ മെഷീൻ kvm/libvirt-ൽ.

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

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

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

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

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

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

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

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

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

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

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

#sudo bash

എങ്ങനെ…?സുഡോയെക്കുറിച്ചുള്ള ഹോളിവാറുകൾക്കുള്ള കാനോനിക്കൽ ട്രിഗറാണ് മുകളിലുള്ള വരി. സി ബിоകൂടുതൽ അവസരങ്ങൾ വരുന്നുоവലിയ ഉത്തരവാദിത്തം. നിങ്ങൾക്ക് അത് സ്വയം ഏറ്റെടുക്കാൻ കഴിയുമോ എന്നതാണ് ചോദ്യം. സുഡോ ഈ രീതിയിൽ ഉപയോഗിക്കുന്നത് അൽപം ശ്രദ്ധിച്ചില്ലെന്നാണ് പലരും കരുതുന്നത്. എന്നിരുന്നാലും:

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

എന്തുകൊണ്ട് ZFS അല്ല...?ഞങ്ങളുടെ കമ്പ്യൂട്ടറിൽ സോഫ്‌റ്റ്‌വെയർ ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ, ഈ സോഫ്റ്റ്‌വെയറിന്റെ ഡെവലപ്പർമാർക്ക് ഡ്രൈവ് ചെയ്യാനായി ഞങ്ങളുടെ ഹാർഡ്‌വെയർ ഞങ്ങൾ കടം കൊടുക്കുന്നു.
ഞങ്ങളുടെ ഡാറ്റയുടെ സുരക്ഷിതത്വത്തോടെ ഈ സോഫ്റ്റ്‌വെയറിനെ ഞങ്ങൾ വിശ്വസിക്കുമ്പോൾ, ഈ ഡാറ്റ പുനഃസ്ഥാപിക്കുന്നതിനുള്ള ചെലവിന് തുല്യമായ ലോൺ ഞങ്ങൾ എടുക്കുന്നു, അത് എന്നെങ്കിലും ഞങ്ങൾ അടച്ചുതീർക്കേണ്ടിവരും.

ഈ വീക്ഷണകോണിൽ, ZFS ഒരു ഫെരാരിയാണ്, mdadm+lvm ഒരു സൈക്കിൾ പോലെയാണ്.

ആത്മനിഷ്ഠമായി, ഫെരാരിക്ക് പകരം അജ്ഞാതരായ വ്യക്തികൾക്ക് ക്രെഡിറ്റിൽ ഒരു ബൈക്ക് കടം കൊടുക്കാനാണ് രചയിതാവ് ഇഷ്ടപ്പെടുന്നത്. അവിടെ, ഇഷ്യുവിന്റെ വില ഉയർന്നതല്ല. അവകാശങ്ങൾ ആവശ്യമില്ല. ട്രാഫിക് നിയമങ്ങളേക്കാൾ ലളിതമാണ്. പാർക്കിംഗ് സൗജന്യമാണ്. ക്രോസ്-കൺട്രി കഴിവ് മികച്ചതാണ്. നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഒരു സൈക്കിളിൽ കാലുകൾ അറ്റാച്ചുചെയ്യാം, നിങ്ങളുടെ സ്വന്തം കൈകൊണ്ട് ഒരു സൈക്കിൾ നന്നാക്കാം.

പിന്നെന്തിനാ BTRFS...?ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ബൂട്ട് ചെയ്യുന്നതിന്, ബോക്‌സിന് പുറത്ത് ലെഗസി/ബയോസ് ഗ്രബ് പിന്തുണയ്‌ക്കുന്ന ഒരു ഫയൽ സിസ്റ്റം ആവശ്യമാണ്, അതേ സമയം ലൈവ് സ്‌നാപ്പ്‌ഷോട്ടുകളെ പിന്തുണയ്‌ക്കുന്നു. /boot പാർട്ടീഷനായി ഞങ്ങൾ ഇത് ഉപയോഗിക്കും. കൂടാതെ, / (റൂട്ട്) എന്നതിനായി ഈ എഫ്എസ് ഉപയോഗിക്കാൻ രചയിതാവ് താൽപ്പര്യപ്പെടുന്നു, മറ്റേതെങ്കിലും സോഫ്‌റ്റ്‌വെയറിനായി നിങ്ങൾക്ക് എൽവിഎമ്മിൽ പ്രത്യേക പാർട്ടീഷനുകൾ സൃഷ്‌ടിക്കാനും ആവശ്യമായ ഡയറക്‌ടറികളിൽ അവ മൌണ്ട് ചെയ്യാനും കഴിയുമെന്ന കാര്യം മറക്കരുത്.

ചിത്രങ്ങളൊന്നുമില്ല വെർച്വൽ മെഷീനുകൾ, ഈ ഫയൽ സിസ്റ്റത്തിൽ ഞങ്ങൾ ഒരു ഡാറ്റാബേസുകളും സംഭരിക്കില്ല.
സിസ്റ്റം ഓഫ് ചെയ്യാതെ തന്നെ സ്‌നാപ്പ്ഷോട്ടുകൾ സൃഷ്‌ടിക്കാൻ മാത്രമേ ഈ എഫ്എസ് ഉപയോഗിക്കൂ, തുടർന്ന് ഈ സ്‌നാപ്പ്‌ഷോട്ടുകൾ അയയ്ക്കുക/സ്വീകരിക്കുക ഉപയോഗിച്ച് ഒരു ബാക്കപ്പ് ഡിസ്‌കിലേക്ക് മാറ്റുക.

കൂടാതെ, രചയിതാവ് സാധാരണയായി ഹാർഡ്‌വെയറിൽ ഒരു മിനിമം സോഫ്‌റ്റ്‌വെയർ സൂക്ഷിക്കാനും 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 : ആരംഭം= 2048, വലുപ്പം= 1953523120, തരം=fd, ബൂട്ടബിൾ
EOF
#sfഡിസ്ക് /dev/sdg <hdd.part
#sfഡിസ്ക് /dev/sdh <hdd.part
#sfഡിസ്ക് /dev/sdi <hdd.part
#sfഡിസ്ക് /dev/sdj <hdd.part
#sfഡിസ്ക് /dev/sdk <hdd.part
#sfഡിസ്ക് /dev/sdl <hdd.part
#sfഡിസ്ക് /dev/sdm <hdd.part
#sfഡിസ്ക് /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 : ആരംഭം= 2048, വലുപ്പം= 2097152, തരം=fd, ബൂട്ടബിൾ
/dev/sda2 : ആരംഭം= 2099200, വലുപ്പം= 3300950016, തരം=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 ഇൻസ്റ്റാളേഷൻ

മൊത്തത്തിൽ, സിസ്റ്റം ഇൻസ്റ്റാൾ ചെയ്യാൻ ആവശ്യമായ എല്ലാം ഞങ്ങളുടെ പക്കലുണ്ട്.

പരിസ്ഥിതിയിൽ നിന്ന് സിസ്റ്റം ഇൻസ്റ്റലേഷൻ വിസാർഡ് സമാരംഭിക്കുക. Ubuntu ലൈവ്. സ്റ്റാൻഡേർഡ് ഇൻസ്റ്റാളേഷൻ. ഡിസ്ക് തിരഞ്ഞെടുക്കൽ ഘട്ടത്തിൽ മാത്രം നിങ്ങൾ ഇനിപ്പറയുന്നവ വ്യക്തമാക്കേണ്ടതുണ്ട്:

• /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 വോള്യങ്ങൾ സൃഷ്ടിക്കും.

നമുക്ക് ഇൻസ്റ്റലേഷൻ ആരംഭിക്കാം...

ഒരു ബൂട്ട്ലോഡർ ഇൻസ്റ്റലേഷൻ പിശക് നിങ്ങളെ അറിയിക്കുന്ന ഒരു മോഡൽ ഡയലോഗ് ബോക്സോടെയാണ് ഇൻസ്റ്റലേഷൻ അവസാനിക്കുന്നത്. നിർഭാഗ്യവശാൽ, ഡിഫോൾട്ട് ടൂളുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ ഡയലോഗ് ബോക്സിൽ നിന്ന് പുറത്തുകടന്ന് ഇൻസ്റ്റാളേഷൻ തുടരാൻ കഴിയില്ല. സിസ്റ്റത്തിൽ നിന്ന് ലോഗ് ഔട്ട് ചെയ്ത് വീണ്ടും ലോഗിൻ ചെയ്ത് ഒരു വൃത്തിയുള്ള ഡെസ്ക്ടോപ്പിലേക്ക് മടങ്ങുക. Ubuntu ലൈവ്. ടെർമിനൽ തുറന്ന് വീണ്ടും:

#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 6 ബ്ലോക്ക് കാഷെ വലുപ്പം 2020 ന് അനുയോജ്യമായ ഒരു മൂല്യത്തിലേക്ക് സജ്ജമാക്കുക. സൃഷ്ടിച്ചതിനുശേഷം സ്ഥിരസ്ഥിതി മൂല്യം മാറ്റമില്ലാതെ തുടരുന്നതായി തോന്നുന്നു. Linux, വളരെക്കാലമായി പര്യാപ്തമല്ല.
• അറേ ചെക്കുകളുടെ/സിൻക്രൊണൈസേഷനുകളുടെ കാലയളവിനായി കുറഞ്ഞത് 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

സജീവമാക്കൽ {
തിൻ_പൂൾ_ഓട്ടോഎക്സ്റ്റെൻഡ്_ത്രെഷോൾഡ്=90
തിൻ_പൂൾ_ഓട്ടോഎക്സ്റ്റെൻഡ്_പെർസെന്റ്=5
}
വിഹിതം {
കാഷെ_പൂൾ_മാക്സ്_ചങ്ക്സ്=2097152
}
ഉപകരണങ്ങൾ {
global_filter=["r|^/dev/.*_corig$|","r|^/dev/.*_cdata$|","r|^/dev/.*_cmeta$|","r|^/dev/.*_cmeta$|","r|^/dev/.*gpv$|","r |^/dev/images/.*$|","r|^/dev/mapper/images.*$|","r|^/dev/backup/.*$|","r|^/dev/mapper/backup.*$|"]
ഇഷ്യൂ_ഡിസ്കാർഡുകൾ=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' മോഡൽ='വിർട്ടിയോ-എസ്‌സി‌എസ്‌ഐ'>




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

BTRFS ബാക്കപ്പ്

കൂടെ റെഡിമെയ്ഡ് സ്ക്രിപ്റ്റുകൾ ഉപയോഗിക്കുക അങ്ങേയറ്റം ജാഗ്രതയും സ്വന്തം ഉത്തരവാദിത്തത്തിൽരചയിതാവ് ഈ കോഡ് സ്വയം എഴുതിയതും തനിക്കുവേണ്ടി മാത്രമുള്ളതുമാണ്. പരിചയസമ്പന്നരായ നിരവധി ഉപയോക്താക്കൾ ഉണ്ടെന്ന് എനിക്ക് ഉറപ്പുണ്ട് Linux സമാനമായ ക്രച്ചസുകളും വികസനങ്ങളും ഉണ്ട്, മറ്റുള്ളവരെ പകർത്തേണ്ട ആവശ്യമില്ല.

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

#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 ഡിഫോൾട്ടുകൾ,space_cache,noatime,nodiratime 0 2
/dev/mapper/backup-backup /backup/btrfs/back btrfs ഡിഫോൾട്ടുകൾ,space_cache,noatime,nodiratime 0 2
EOF
#മൗണ്ട് -എ
#അപ്ഡേറ്റ്-ഇനിട്രാംഫ്സ് -u
#അപ്ഡേറ്റ്-ഗ്രബ്

ബാക്കപ്പുകൾക്കായി നമുക്ക് ഡയറക്ടറികൾ സൃഷ്ടിക്കാം:

#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="$(റിയൽപാത്ത് $0)"
SCRIPT_DIR="$(ഡയറക്ട് നാമം $SCRIPT_FILE)"
SCRIPT_NAME="$(ബേസ് നെയിം -s .sh $SCRIPT_FILE)"

ലോക്ക്_ഫയൽ="/dev/shm/$SCRIPT_NAME.ലോക്ക്"
തീയതി_PREFIX='%Y-%m-%d'
തീയതി_ഫോർമാറ്റ്=$തീയതി_പ്രീഫിക്സ്'-%എച്ച്-%എം-%എസ്'
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]'
ബേസ്_സഫിക്സ് = ".@ബേസ്"
പെൻഡ്_സഫിക്സ്=".@പെൻഡ്"
SNAP_SUFFIX=".@സ്നാപ്പ്"
മൌണ്ടുകൾ="/ബാക്കപ്പ്/btrfs/"
ബാക്കപ്പുകൾ="/ബാക്കപ്പ്/btrfs/ബാക്ക്/റിമോട്ട്/"

ഫംഗ്ഷൻ ടെർമിനേറ്റ്()
{
എക്കോ "$1" >&2
പുറത്തുകടക്കുക 1
}

ഫംഗ്ഷൻ wait_lock()
{
ആട്ടിൻകൂട്ടം 98
}

ഫംഗ്ഷൻ wait_lock_or_terminate()
{
എക്കോ "ലോക്കിനായി കാത്തിരിക്കുന്നു..."
wait_lock || അവസാനിപ്പിക്കുക "ലോക്ക് നേടുന്നതിൽ പരാജയപ്പെട്ടു. പുറത്തുകടക്കുന്നു..."
എക്കോ "ലോക്ക് കിട്ടി..."
}

ഫംഗ്ഷൻ സഫിക്സ്()
{
FORMATTED_DATE=$(തീയതി +"$DATE_FORMAT")
എക്കോ "$SNAP_SUFFIX.$FORMATTED_DATE"
}

ഫംഗ്ഷൻ ഫിൽറ്റർ()
{
ഫോർമാറ്റ് ചെയ്ത_തീയതി=$(തീയതി --തീയതി="$1" +"$DATE_PREFIX")
എക്കോ "$SNAP_SUFFIX.$FORMATTED_DATE"
}

ഫംഗ്ഷൻ ബാക്കപ്പ്()
{
SOURCE_PATH="$mounts$1"
TARGET_PATH="$ബാക്കപ്പുകൾ$1"
SOURCE_BASE_PATH="$MOUNTS$1$BASE_SUFFIX"
TARGET_BASE_PATH="$BACKUPS$1$BASE_SUFFIX"
TARGET_BASE_DIR="$(ഡയറക്ടർ നാമം $TARGET_BASE_PATH)"
SOURCE_PEND_PATH="$മൗണ്ടുകൾ$1$PEND_SUFFIX"
TARGET_PEND_PATH="$ബാക്കപ്പുകൾ$1$PEND_SUFFIX"
[ -d "$SOURCE_BASE_PATH" ] ആണെങ്കിൽ
അപ്പോള്
എക്കോ "$SOURCE_BASE_PATH കണ്ടെത്തി"
മറ്റാരെങ്കിലും
echo "$SOURCE_BASE_PATH എന്നതിന്റെ സ്നാപ്പ്ഷോട്ട് $SOURCE_PATH യിൽ നിന്ന് $SOURCE_BASE_PATH ലേക്ക് സൃഷ്ടിക്കുന്ന ഫയൽ കണ്ടെത്തിയില്ല"
btrfs സബ്‌വോളിയം സ്നാപ്പ്ഷോട്ട് -r $SOURCE_PATH $SOURCE_BASE_PATH
സമന്വയം
[ -d "$TARGET_BASE_PATH" ] ആണെങ്കിൽ
അപ്പോള്
echo "$TARGET_BASE_PATH ഉറവിടവുമായി സമന്വയിക്കുന്നില്ലെന്ന് കണ്ടെത്തി... നീക്കം ചെയ്യുന്നു..."
btrfs സബ്‌വോളിയം ഇല്ലാതാക്കുക -c $TARGET_BASE_PATH
സമന്വയം
fi
fi
[ -d "$TARGET_BASE_PATH" ] ആണെങ്കിൽ
അപ്പോള്
എക്കോ "$TARGET_BASE_PATH കണ്ടെത്തി"
മറ്റാരെങ്കിലും
echo "$TARGET_BASE_PATH കണ്ടെത്തിയില്ല. $TARGET_BASE_DIR ലേക്ക് സമന്വയിപ്പിക്കുന്നു"
btrf-കൾ $SOURCE_BASE_PATH അയയ്ക്കുന്നു | btrf-കൾക്ക് $TARGET_BASE_DIR ലഭിക്കുന്നു
സമന്വയം
fi
[ -d "$SOURCE_PEND_PATH" ] ആണെങ്കിൽ
അപ്പോള്
echo "$SOURCE_PEND_PATH നീക്കം ചെയ്യുന്നത് കണ്ടെത്തി..."
btrfs സബ്‌വോളിയം ഇല്ലാതാക്കുക -c $SOURCE_PEND_PATH
സമന്വയം
fi
btrfs സബ്‌വോളിയം സ്നാപ്പ്ഷോട്ട് -r $SOURCE_PATH $SOURCE_PEND_PATH
സമന്വയം
[ -d "$TARGET_PEND_PATH" ] ആണെങ്കിൽ
അപ്പോള്
echo "$TARGET_PEND_PATH നീക്കം ചെയ്യുന്നത് കണ്ടെത്തി..."
btrfs സബ്‌വോളിയം ഇല്ലാതാക്കുക -c $TARGET_PEND_PATH
സമന്വയം
fi
എക്കോ "$SOURCE_PEND_PATH, $TARGET_PEND_PATH ലേക്ക് അയയ്ക്കുന്നു"
btrfs send -p $SOURCE_BASE_PATH $SOURCE_PEND_PATH | btrfs $TARGET_BASE_DIR സ്വീകരിക്കുന്നു
സമന്വയം
TARGET_DATE_SUFFIX=$(സഫിക്സ്)
btrfs സബ്‌വോളിയം സ്നാപ്പ്ഷോട്ട് -r $TARGET_PEND_PATH "$TARGET_PATH$TARGET_DATE_SUFFIX"
സമന്വയം
btrfs ഉപവോള്യം ഇല്ലാതാക്കുക -c $SOURCE_BASE_PATH
സമന്വയം
btrfs സബ്‌വോളിയം ഇല്ലാതാക്കുക -c $TARGET_BASE_PATH
സമന്വയം
എംവി $SOURCE_PEND_PATH $SOURCE_BASE_PATH
എംവി $TARGET_PEND_PATH $TARGET_BASE_PATH
സമന്വയം
}

ഫംഗ്ഷൻ ലിസ്റ്റ്()
{
LIST_TARGET_BASE_PATH="$BACKUPS$1$BASE_SUFFIX"
LIST_TARGET_BASE_DIR="$(ഡയറക്ടർ നാമം $LIST_TARGET_BASE_PATH)"
LIST_TARGET_BASE_NAME="$(ബേസ് നെയിം -s .$BASE_SUFFIX $LIST_TARGET_BASE_PATH)"
"$LIST_TARGET_BASE_DIR" -maxdepth 1 -mindepth 1 -type d -printf "%fn" | grep "${LIST_TARGET_BASE_NAME/$BASE_SUFFIX/$SNAP_SUFFIX}.$DATE_REGEX" കണ്ടെത്തുക.
}

ഫംഗ്ഷൻ നീക്കം ചെയ്യുക()
{
നീക്കംചെയ്യുക_TARGET_BASE_PATH="$ബാക്കപ്പുകൾ$1$BASE_SUFFIX"
REMOVE_TARGET_BASE_DIR="$(ഡയറക്ടർ നാമം $REMOVE_TARGET_BASE_PATH)"
btrfs സബ്‌വോളിയം ഇല്ലാതാക്കുക -c $REMOVE_TARGET_BASE_DIR/$2
സമന്വയം
}

ഫംഗ്ഷൻ removeall()
{
തീയതി_ഓഫ്‌സെറ്റ്="$2"
ഫിൽട്ടർ="$("$DATE_OFFSET" ഫിൽട്ടർ ചെയ്യുക)"
വായിക്കുമ്പോൾ -r സ്നാപ്പ്ഷോട്ട് ; ചെയ്യുക
"$1" "$SNAPSHOT" നീക്കം ചെയ്യുക
ചെയ്തു <(ലിസ്റ്റ് "$1" | grep "$FILTER")

}

(
കമാൻഡ്="$1"
ഷിഫ്റ്റ്

"$COMMAND" എന്ന കേസ്
"--സഹായം")
എക്കോ "സഹായം"
;;
"സഫിക്സ്")
സഫിക്സ്
;;
"ഫിൽട്ടർ")
"$1" ഫിൽട്ടർ ചെയ്യുക
;;
"ബാക്കപ്പ്")
കാത്തിരിക്കുക_ലോക്ക്_അല്ലെങ്കിൽ_ടെർമിനേറ്റ് ചെയ്യുക
"$1" ബാക്കപ്പ് ചെയ്യുക
;;
"ലിസ്റ്റ്")
"$1" ലിസ്റ്റ്
;;
"നീക്കം ചെയ്യുക")
കാത്തിരിക്കുക_ലോക്ക്_അല്ലെങ്കിൽ_ടെർമിനേറ്റ് ചെയ്യുക
"$1" "$2" നീക്കം ചെയ്യുക
;;
"എല്ലാം നീക്കം ചെയ്യുക")
കാത്തിരിക്കുക_ലോക്ക്_അല്ലെങ്കിൽ_ടെർമിനേറ്റ് ചെയ്യുക
"$1" "$2" എല്ലാം നീക്കം ചെയ്യുക
;;
*)
"ഒന്നുമില്ല.." എന്ന് പ്രതിധ്വനിക്കുക.
;;
സി
) 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="$(റിയൽപാത്ത് $0)"
SCRIPT_DIR="$(ഡയറക്ട് നാമം $SCRIPT_FILE)"
SCRIPT_NAME="$(ബേസ് നെയിം -s .sh $SCRIPT_FILE)"

BACKUP_SCRIPT="$SCRIPT_DIR/btrfs-backup.sh"
RETENTION="-60 ദിവസം"
$BACKUP_SCRIPT ബാക്കപ്പ് റൂട്ട്/@
$BACKUP_SCRIPT എല്ലാ റൂട്ടും നീക്കം ചെയ്യുക/@ "$RETENTION"
$BACKUP_SCRIPT ബാക്കപ്പ് റൂട്ട്/@home
$BACKUP_SCRIPT എല്ലാ റൂട്ടും നീക്കം ചെയ്യുക/@home "$RETENTION"
$BACKUP_SCRIPT ബാക്കപ്പ് ബൂട്ട്/
$BACKUP_SCRIPT എല്ലാ ബൂട്ടും നീക്കം ചെയ്യുക/ "$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="$(റിയൽപാത്ത് $0)"
SCRIPT_DIR="$(ഡയറക്ട് നാമം $SCRIPT_FILE)"
SCRIPT_NAME="$(ബേസ് നെയിം -s .sh $SCRIPT_FILE)"

ലോക്ക്_ഫയൽ="/dev/shm/$SCRIPT_NAME.ലോക്ക്"
തീയതി_PREFIX='%Y-%m-%d'
തീയതി_ഫോർമാറ്റ്=$തീയതി_പ്രീഫിക്സ്'-%എച്ച്-%എം-%എസ്'
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]'
ബേസ്_സഫിക്സ്=".ബേസ്"
PEND_SUFFIX=".ചെലവ്"
SNAP_SUFFIX=".സ്നാപ്പ്"
ബാക്കപ്പുകൾ="ബാക്കപ്പ്"
BACKUPS_POOL="തിൻ-പൂൾ"

കയറ്റുമതി ചെയ്യുക LVM_SUPPRESS_FD_WARNINGS=1

ഫംഗ്ഷൻ ടെർമിനേറ്റ്()
{
എക്കോ "$1" >&2
പുറത്തുകടക്കുക 1
}

ഫംഗ്ഷൻ wait_lock()
{
ആട്ടിൻകൂട്ടം 98
}

ഫംഗ്ഷൻ wait_lock_or_terminate()
{
എക്കോ "ലോക്കിനായി കാത്തിരിക്കുന്നു..."
wait_lock || അവസാനിപ്പിക്കുക "ലോക്ക് നേടുന്നതിൽ പരാജയപ്പെട്ടു. പുറത്തുകടക്കുന്നു..."
എക്കോ "ലോക്ക് കിട്ടി..."
}

ഫംഗ്ഷൻ സഫിക്സ്()
{
FORMATTED_DATE=$(തീയതി +"$DATE_FORMAT")
എക്കോ "$SNAP_SUFFIX.$FORMATTED_DATE"
}

ഫംഗ്ഷൻ ഫിൽറ്റർ()
{
ഫോർമാറ്റ് ചെയ്ത_തീയതി=$(തീയതി --തീയതി="$1" +"$DATE_PREFIX")
എക്കോ "$SNAP_SUFFIX.$FORMATTED_DATE"
}

ഫംഗ്ഷൻ read_thin_id {
lvs --rows --reportformat അടിസ്ഥാന --quiet -othin_id "$1/$2" | awk '{print $2}'
}

ഫംഗ്ഷൻ read_pool_lv {
lvs --rows --reportformat അടിസ്ഥാന --quiet -opool_lv "$1/$2" | awk '{print $2}'
}

ഫംഗ്ഷൻ read_lv_dm_path {
lvs --rows --reportformat അടിസ്ഥാന --quiet -olv_dm_path "$1/$2" | awk '{print $2}'
}

ഫംഗ്ഷൻ read_lv_active {
lvs --rows --reportformat അടിസ്ഥാന --quiet -olv_active "$1/$2" | awk '{print $2}'
}

ഫംഗ്ഷൻ read_lv_chunk_size {
lvs --rows --reportformat അടിസ്ഥാന --quiet --units b --nosuffix -ochunk_size "$1/$2" | awk '{print $2}'
}

ഫംഗ്ഷൻ read_lv_size {
lvs --rows --reportformat അടിസ്ഥാന --quiet --units b --nosuffix -olv_size "$1/$2" | awk '{print $2}'
}

ഫംഗ്ഷൻ ആക്ടിവേറ്റ്_വോളിയം {
lvchange -ay -Ky "$1/$2"
}

ഫംഗ്ഷൻ നിർജ്ജീവമാക്കുക_വോള്യം {
lvchange -ഒരു "$1/$2"
}

ഫംഗ്ഷൻ read_thin_metadata_snap {
dmsetup സ്റ്റാറ്റസ് "$1" | awk '{print $7}'
}

thindiff() ഫംഗ്ഷൻ
{
ഡിഐഎഫ്എഫ്_വിജി="$1"
ഡിഎഫ്എഫ്_സോഴ്‌സ്="$2"
ഡിഫ്ഫ്_ലക്ഷ്യം="$3"
DIFF_SOURCE_POOL=$(റീഡ്_പൂൾ_എൽവി $DIFF_VG $DIFF_SOURCE)
DIFF_TARGET_POOL=$(റീഡ്_പൂൾ_എൽവി $DIFF_VG $DIFF_TARGET)

[ "$DIFF_SOURCE_POOL" == "" ] ആണെങ്കിൽ
അപ്പോള്
(>&2 "സോഴ്സ് എൽവി നേർത്തതല്ല" എന്ന് പ്രതിധ്വനിക്കുന്നു.)
പുറത്തുകടക്കുക 1
fi

[ "$DIFF_TARGET_POOL" == "" ] ആണെങ്കിൽ
അപ്പോള്
(>&2 "ടാർഗെറ്റ് എൽവി നേർത്തതല്ല" എന്ന് പ്രതിധ്വനിക്കുന്നു.)
പുറത്തുകടക്കുക 1
fi

[ "$DIFF_SOURCE_POOL" != "$DIFF_TARGET_POOL" ] ആണെങ്കിൽ
അപ്പോള്
(>&2 പ്രതിധ്വനിക്കുക "ഉറവിടവും ലക്ഷ്യ എൽവികളും വ്യത്യസ്ത നേർത്ത പൂളുകളിൽ പെടുന്നു.")
പുറത്തുകടക്കുക 1
fi

DIFF_POOL_PATH=$(read_lv_dm_path $DIFF_VG $DIFF_SOURCE_POOL)
DIFF_SOURCE_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"_tമെറ്റാ
DIFF_POOL_METADATA_SNAP=$(മെറ്റാഡാറ്റ_സ്നാപ്പ്_റീഡ്_തിൻ_$DIFF_POOL_PATH_TPOOL)

[ "$DIFF_POOL_METADATA_SNAP" != "-" ] ആണെങ്കിൽ
അപ്പോള്
(>&2 എക്കോ "നേർത്ത പൂൾ മെറ്റാഡാറ്റ സ്നാപ്പ്ഷോട്ട് ഇതിനകം നിലവിലുണ്ട്. പഴകിയ ഒന്ന് അനുമാനിക്കാം. 5 സെക്കൻഡിനുള്ളിൽ മെറ്റാഡാറ്റ സ്നാപ്പ്ഷോട്ട് പുറത്തിറക്കും.")
ഉറക്കം 5
dmsetup സന്ദേശം $DIFF_POOL_PATH_TPOOL 0 release_metadata_snap
fi

dmsetup സന്ദേശം $DIFF_POOL_PATH_TPOOL 0 reserve_metadata_snap
DIFF_POOL_METADATA_SNAP=$(മെറ്റാഡാറ്റ_സ്നാപ്പ്_റീഡ്_തിൻ_$DIFF_POOL_PATH_TPOOL)

[ "$DIFF_POOL_METADATA_SNAP" == "-" ] ആണെങ്കിൽ
അപ്പോള്
(>&2 "നേർത്ത പൂൾ മെറ്റാഡാറ്റ സ്നാപ്പ്ഷോട്ട് സൃഷ്ടിക്കുന്നതിൽ പരാജയപ്പെട്ടു" എന്നതിന്റെ പ്രതിധ്വനിയാണ്.)
പുറത്തുകടക്കുക 1
fi

#മെറ്റാഡാറ്റ സ്നാപ്പ്ഷോട്ട് നേരത്തെ റിലീസ് ചെയ്യേണ്ടതിനാൽ ഞങ്ങൾ ഔട്ട്പുട്ട് വേരിയബിളിൽ സൂക്ഷിക്കുന്നു.
DIFF_DATA=$(thin_delta -m$DIFF_POOL_METADATA_SNAP --snap1 $DIFF_SOURCE_ID --snap2 $DIFF_TARGET_ID $DIFF_POOL_PATH_TMETA)

dmsetup സന്ദേശം $DIFF_POOL_PATH_TPOOL 0 release_metadata_snap

എക്കോ $"$DIFF_DATA" | grep -E 'വ്യത്യസ്തം|ഇടത്_മാത്രം|വലത്_മാത്രം' | sed's/

}

ഫംഗ്ഷൻ thinsync()
{
SYNC_VG="$1"
സമന്വയിപ്പിക്കുക_പെൻഡ്="$2"
സമന്വയ അടിസ്ഥാനം="$3"
സമന്വയം_ലക്ഷ്യം="$4"
SYNC_PEND_POOL=$(റീഡ്_പൂൾ_എൽവി $SYNC_VG $SYNC_PEND)
SYNC_BLOCK_SIZE=$(read_lv_chunk_size $SYNC_VG $SYNC_PEND_POOL)
SYNC_PEND_PATH=$(റീഡ്_എൽവി_ഡിഎം_പാത്ത് $SYNC_VG $SYNC_PEND)

സജീവമാക്കുക_വോള്യം $SYNC_VG $SYNC_PEND

വായിക്കുമ്പോൾ -r SYNC_ACTION SYNC_OFFSET SYNC_LENGTH ; ചെയ്യുക
SYNC_OFFSET_BYTES=$((SYNC_OFFSET * SYNC_BLOCK_SIZE))
SYNC_LENGTH_BYTES=$((SYNC_LENGTH * SYNC_BLOCK_SIZE))
[ "$SYNC_ACTION" == "പകർത്തുക" ] ആണെങ്കിൽ
അപ്പോള്
ddrescue --quiet --force --input-position=$SYNC_OFFSET_BYTES --output-position=$SYNC_OFFSET_BYTES --size=$SYNC_LENGTH_BYTES "$SYNC_PEND_PATH" "$SYNC_TARGET"
fi

[ "$SYNC_ACTION" == "നിരസിക്കുക" ] എങ്കിൽ
അപ്പോള്
blkdiscard -o $SYNC_OFFSET_BYTES -l $SYNC_LENGTH_BYTES "$SYNC_TARGET"
fi
ചെയ്തു <(thindiff "$SYNC_VG" "$SYNC_PEND" "$SYNC_BASE")
}

ഫംഗ്ഷൻ discard_volume()
{
ഡിസ്കാർഡ്_വിജി="$1"
ഡിസ്കാർഡ്_എൽവി="$2"
DISCARD_LV_PATH=$(read_lv_dm_path "$DISCARD_VG" "$DISCARD_LV")
[ "$DISCARD_LV_PATH" != "" ] ആണെങ്കിൽ
അപ്പോള്
എക്കോ "$DISCARD_LV_PATH കണ്ടെത്തി"
മറ്റാരെങ്കിലും
എക്കോ "$DISCARD_VG-യിൽ $DISCARD_LV കണ്ടെത്തിയില്ല"
പുറത്തുകടക്കുക 1
fi
ഡിസ്കാർഡ്_എൽവി_പൂൾ=$(റീഡ്_പൂൾ_എൽവി $ഡിസ്കാർഡ്_വിജി $ഡിസ്കാർഡ്_എൽവി)
DISCARD_LV_SIZE=$("$DISCARD_VG" "$DISCARD_LV" എന്നതിന്റെ_lv_വലുപ്പം വായിക്കുക)
lvremove -y --നിശബ്ദമാക്കുക "$DISCARD_LV_PATH" || എക്സിറ്റ് 1
lvcreate --thin-pool "$DISCARD_LV_POOL" -V "$DISCARD_LV_SIZE"B --name "$DISCARD_LV" "$DISCARD_VG" || എക്സിറ്റ് 1
}

ഫംഗ്ഷൻ ബാക്കപ്പ്()
{
സോഴ്‌സ്_വിജി="$1"
സോഴ്‌സ്_എൽവി="$2"
TARGET_VG="$ബാക്കപ്പുകൾ"
ടാർഗെറ്റ്_എൽവി="$സോഴ്‌സ്_വിജി-$സോഴ്‌സ്_എൽവി"
SOURCE_BASE_LV="$SOURCE_LV$BASE_Suffix"
ടാർഗെറ്റ്_ബേസ്_എൽവി="$ടാർഗെറ്റ്_എൽവി$ബേസ്_സഫിക്സ്"
സോഴ്‌സ്_പിEND_എൽവി="$സോഴ്‌സ്_എൽവി$പിEND_സഫിക്സ്"
ടാർഗെറ്റ്_പിEND_എൽവി="$ടാർഗെറ്റ്_എൽവി$പിEND_സഫിക്സ്"
SOURCE_BASE_LV_PATH=$(read_lv_dm_path "$SOURCE_VG" "$SOURCE_BASE_LV")
SOURCE_PEND_LV_PATH=$("$SOURCE_VG" "$SOURCE_PEND_LV" എന്നതിന്റെ_lv_dm_path വായിക്കുക)
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")

[ "$SOURCE_BASE_LV_PATH" != "" ] ആണെങ്കിൽ
അപ്പോള്
എക്കോ "$SOURCE_BASE_LV_PATH കണ്ടെത്തി"
മറ്റാരെങ്കിലും
echo "$SOURCE_VG/$SOURCE_LV യിൽ നിന്ന് $SOURCE_VG/$SOURCE_BASE_LV ലേക്ക് സ്നാപ്പ്ഷോട്ട് സൃഷ്ടിക്കുന്ന ഉറവിട ബേസ് കണ്ടെത്തിയില്ല"
lvcreate --quiet --snapshot --name "$SOURCE_BASE_LV" "$SOURCE_VG/$SOURCE_LV" || എക്സിറ്റ് 1
SOURCE_BASE_LV_PATH=$(read_lv_dm_path "$SOURCE_VG" "$SOURCE_BASE_LV")
സജീവമാക്കുക_വോള്യം "$SOURCE_VG" "$SOURCE_BASE_LV"
echo "നമുക്ക് ബൂട്ട്‌സ്ട്രാപ്പ് ചെയ്യേണ്ടതിനാൽ $SOURCE_BASE_LV_PATH ഉപേക്ഷിക്കുന്നു."
SOURCE_BASE_POOL=$(റീഡ്_പൂൾ_എൽവി $SOURCE_VG $SOURCE_BASE_LV)
SOURCE_BASE_CHUNK_SIZE=$(read_lv_chunk_size $SOURCE_VG $SOURCE_BASE_POOL)
"$SOURCE_VG" എന്ന വാള്യം നിരസിക്കുക "$SOURCE_BASE_LV"
സമന്വയം
[ "$TARGET_BASE_LV_PATH" != "" ] ആണെങ്കിൽ
അപ്പോള്
echo "$TARGET_BASE_LV_PATH ഉറവിടവുമായി സമന്വയിക്കുന്നില്ലെന്ന് കണ്ടെത്തി... നീക്കംചെയ്യുന്നു..."
lvremove -y --നിശബ്ദമാക്കുക $TARGET_BASE_LV_PATH || എക്സിറ്റ് 1
TARGET_BASE_LV_PATH=$(read_lv_dm_path "$TARGET_VG" "$TARGET_BASE_LV")
സമന്വയം
fi
fi
SOURCE_BASE_SIZE=$("$SOURCE_VG" "$SOURCE_BASE_LV" എന്നതിന്റെ_lv_വലുപ്പം വായിക്കുക)
[ "$TARGET_BASE_LV_PATH" != "" ] ആണെങ്കിൽ
അപ്പോള്
എക്കോ "$TARGET_BASE_LV_PATH കണ്ടെത്തി"
മറ്റാരെങ്കിലും
echo "$TARGET_VG/$TARGET_LV കണ്ടെത്തിയില്ല. ശൂന്യമായ വോള്യം സൃഷ്ടിക്കുന്നു."
lvcreate --thin-pool "$BACKUPS_POOL" -V "$SOURCE_BASE_SIZE"B --name "$TARGET_BASE_LV" "$TARGET_VG" || എക്സിറ്റ് 1
echo "സ്ട്രാപ്പ് റീബൂട്ട് ചെയ്യണം. $SOURCE_BASE_LV_PATH-ൽ ഉറവിടം ഉപേക്ഷിക്കുന്നു"
സജീവമാക്കുക_വോള്യം "$SOURCE_VG" "$SOURCE_BASE_LV"
SOURCE_BASE_POOL=$(റീഡ്_പൂൾ_എൽവി $SOURCE_VG $SOURCE_BASE_LV)
SOURCE_BASE_CHUNK_SIZE=$(read_lv_chunk_size $SOURCE_VG $SOURCE_BASE_POOL)
"$SOURCE_VG" എന്ന വാള്യം നിരസിക്കുക "$SOURCE_BASE_LV"
TARGET_BASE_POOL=$(റീഡ്_പൂൾ_എൽവി $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")
എക്കോ "$TARGET_BASE_LV_PATH-ൽ ടാർഗെറ്റ് ഉപേക്ഷിക്കുന്നു"
നിരസിക്കുക_വോള്യം "$TARGET_VG" "$TARGET_BASE_LV"
സമന്വയം
fi
[ "$SOURCE_PEND_LV_PATH" != "" ] ആണെങ്കിൽ
അപ്പോള്
echo "$SOURCE_PEND_LV_PATH നീക്കം ചെയ്യുന്നത് കണ്ടെത്തി..."
lvremove -y --നിശബ്ദമാക്കുക "$SOURCE_PEND_LV_PATH" || എക്സിറ്റ് 1
സമന്വയം
fi
lvcreate --quiet --snapshot --name "$SOURCE_PEND_LV" "$SOURCE_VG/$SOURCE_LV" || എക്സിറ്റ് 1
SOURCE_PEND_LV_PATH=$("$SOURCE_VG" "$SOURCE_PEND_LV" എന്നതിന്റെ_lv_dm_path വായിക്കുക)
സമന്വയം
[ "$TARGET_PEND_LV_PATH" != "" ] ആണെങ്കിൽ
അപ്പോള്
echo "$TARGET_PEND_LV_PATH നീക്കം ചെയ്യുന്നത് കണ്ടെത്തി..."
lvremove -y --നിശബ്ദമാക്കുക $TARGET_PEND_LV_PATH
സമന്വയം
fi
lvcreate --quiet --snapshot --name "$TARGET_PEND_LV" "$TARGET_VG/$TARGET_BASE_LV" || എക്സിറ്റ് 1
TARGET_PEND_LV_PATH=$(read_lv_dm_path "$TARGET_VG" "$TARGET_PEND_LV")
SOURCE_PEND_LV_SIZE=$("$SOURCE_VG" "$SOURCE_PEND_LV" എന്നതിന്റെ_lv_വലുപ്പം വായിക്കുക)
lvresize -L "$SOURCE_PEND_LV_SIZE"B "$TARGET_PEND_LV_PATH"
സജീവമാക്കുക_വോള്യം "$TARGET_VG" "$TARGET_PEND_LV"
എക്കോ "$SOURCE_PEND_LV_PATH മുതൽ $TARGET_PEND_LV_PATH വരെ സമന്വയിപ്പിക്കുന്നു"
തിൻസിങ്ക് "$SOURCE_VG" "$SOURCE_PEND_LV" "$SOURCE_BASE_LV" "$TARGET_PEND_LV_PATH" || എക്സിറ്റ് 1
സമന്വയം

TARGET_DATE_SUFFIX=$(സഫിക്സ്)
lvcreate --quiet --snapshot --name "$TARGET_LV$TARGET_DATE_SUFFIX" "$TARGET_VG/$TARGET_PEND_LV" || എക്സിറ്റ് 1
സമന്വയം
lvremove --quiet -y "$SOURCE_BASE_LV_PATH" || എക്സിറ്റ് 1
സമന്വയം
lvremove --quiet -y "$TARGET_BASE_LV_PATH" || എക്സിറ്റ് 1
സമന്വയം
lvrename -y "$SOURCE_VG/$SOURCE_PEND_LV" "$SOURCE_BASE_LV" || എക്സിറ്റ് 1
lvrename -y "$TARGET_VG/$TARGET_PEND_LV" "$TARGET_BASE_LV" || എക്സിറ്റ് 1
സമന്വയം
നിർജ്ജീവമാക്കുക_വോള്യം "$TARGET_VG" "$TARGET_BASE_LV"
നിർജ്ജീവമാക്കുക_വോള്യം "$SOURCE_VG" "$SOURCE_BASE_LV"
}

ഫംഗ്ഷൻ വെരിഫൈ()
{
സോഴ്‌സ്_വിജി="$1"
സോഴ്‌സ്_എൽവി="$2"
TARGET_VG="$ബാക്കപ്പുകൾ"
ടാർഗെറ്റ്_എൽവി="$സോഴ്‌സ്_വിജി-$സോഴ്‌സ്_എൽവി"
SOURCE_BASE_LV="$SOURCE_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")

[ "$SOURCE_BASE_LV_PATH" != "" ] ആണെങ്കിൽ
അപ്പോള്
എക്കോ "$SOURCE_BASE_LV_PATH കണ്ടെത്തി"
മറ്റാരെങ്കിലും
എക്കോ "$SOURCE_BASE_LV_PATH കണ്ടെത്തിയില്ല"
പുറത്തുകടക്കുക 1
fi
[ "$TARGET_BASE_LV_PATH" != "" ] ആണെങ്കിൽ
അപ്പോള്
എക്കോ "$TARGET_BASE_LV_PATH കണ്ടെത്തി"
മറ്റാരെങ്കിലും
എക്കോ "$TARGET_BASE_LV_PATH കണ്ടെത്തിയില്ല"
പുറത്തുകടക്കുക 1
fi
സജീവമാക്കുക_വോള്യം "$TARGET_VG" "$TARGET_BASE_LV"
സജീവമാക്കുക_വോള്യം "$SOURCE_VG" "$SOURCE_BASE_LV"
"$SOURCE_BASE_LV_PATH" നെ "$TARGET_BASE_LV_PATH" മായി താരതമ്യം ചെയ്യുന്ന പ്രതിധ്വനി
cmp "$SOURCE_BASE_LV_PATH" "$TARGET_BASE_LV_PATH"
എക്കോ കഴിഞ്ഞു...
നിർജ്ജീവമാക്കുക_വോള്യം "$TARGET_VG" "$TARGET_BASE_LV"
നിർജ്ജീവമാക്കുക_വോള്യം "$SOURCE_VG" "$SOURCE_BASE_LV"
}

ഫംഗ്ഷൻ പുനഃസമന്വയിപ്പിക്കുക()
{
സോഴ്‌സ്_വിജി="$1"
സോഴ്‌സ്_എൽവി="$2"
TARGET_VG="$ബാക്കപ്പുകൾ"
ടാർഗെറ്റ്_എൽവി="$സോഴ്‌സ്_വിജി-$സോഴ്‌സ്_എൽവി"
SOURCE_BASE_LV="$SOURCE_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")

[ "$SOURCE_BASE_LV_PATH" != "" ] ആണെങ്കിൽ
അപ്പോള്
എക്കോ "$SOURCE_BASE_LV_PATH കണ്ടെത്തി"
മറ്റാരെങ്കിലും
എക്കോ "$SOURCE_BASE_LV_PATH കണ്ടെത്തിയില്ല"
പുറത്തുകടക്കുക 1
fi
[ "$TARGET_BASE_LV_PATH" != "" ] ആണെങ്കിൽ
അപ്പോള്
എക്കോ "$TARGET_BASE_LV_PATH കണ്ടെത്തി"
മറ്റാരെങ്കിലും
എക്കോ "$TARGET_BASE_LV_PATH കണ്ടെത്തിയില്ല"
പുറത്തുകടക്കുക 1
fi
സജീവമാക്കുക_വോള്യം "$TARGET_VG" "$TARGET_BASE_LV"
സജീവമാക്കുക_വോള്യം "$SOURCE_VG" "$SOURCE_BASE_LV"
SOURCE_BASE_POOL=$(റീഡ്_പൂൾ_എൽവി $SOURCE_VG $SOURCE_BASE_LV)
SYNC_BLOCK_SIZE=$(read_lv_chunk_size $SOURCE_VG $SOURCE_BASE_POOL)

"$SOURCE_BASE_LV_PATH" നെ "$TARGET_BASE_LV_PATH" ലേക്ക് എക്കോ സമന്വയിപ്പിക്കുന്നു

CMP_OFFSET=0
[[ "$CMP_OFFSET" != "" ]] ; ചെയ്യുമ്പോൾ
CMP_MISMATCH=$(cmp -i "$CMP_OFFSET" "$SOURCE_BASE_LV_PATH" "$TARGET_BASE_LV_PATH" | grep വ്യത്യാസം | awk '{print $5}' | sed 's/,//g' )
[[ "$CMP_MISMATCH" != "" ]] ആണെങ്കിൽ; പിന്നെ
CMP_OFFSET=$(( CMP_MISMATCH + CMP_OFFSET ))
SYNC_OFFSET_BYTES=$(( ( CMP_OFFSET / SYNC_BLOCK_SIZE ) * SYNC_BLOCK_SIZE ))
SYNC_LENGTH_BYTES=$(( SYNC_BLOCK_SIZE ))
എക്കോ "$SOURCE_BASE_LV_PATH ൽ നിന്ന് $TARGET_BASE_LV_PATH ലേക്ക് $SYNC_OFFSET_BYTES ൽ $SYNC_LENGTH_BYTES ബൈറ്റുകൾ സമന്വയിപ്പിക്കുന്നു"
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"
മറ്റാരെങ്കിലും
സിഎംപി_ഓഫ്‌സെറ്റ്=""
fi
ചെയ്തു
എക്കോ കഴിഞ്ഞു...
നിർജ്ജീവമാക്കുക_വോള്യം "$TARGET_VG" "$TARGET_BASE_LV"
നിർജ്ജീവമാക്കുക_വോള്യം "$SOURCE_VG" "$SOURCE_BASE_LV"
}

ഫംഗ്ഷൻ ലിസ്റ്റ്()
{
ലിസ്റ്റ്_സോഴ്‌സ്_വിജി="$1"
ലിസ്റ്റ്_സോഴ്‌സ്_എൽവി="$2"
ലിസ്റ്റ്_ടാർഗെറ്റ്_വിജി="$ബാക്കപ്പുകൾ"
ലിസ്റ്റ്_ടാർഗെറ്റ്_എൽവി="$ലിസ്റ്റ്_സോഴ്‌സ്_വിജി-$ലിസ്റ്റ്_സോഴ്‌സ്_എൽവി"
ലിസ്റ്റ്_ടാർഗെറ്റ്_ബേസ്_എൽവി="$ലിസ്റ്റ്_ടാർഗെറ്റ്_എൽവി$സ്നാപ്പ്_സഫിക്സ്"
lvs -olv_name | grep "$LIST_TARGET_BASE_LV.$DATE_REGEX"
}

ഫംഗ്ഷൻ നീക്കം ചെയ്യുക()
{
നീക്കംചെയ്യുക_TARGET_VG="$ബാക്കപ്പുകൾ"
നീക്കംചെയ്യുക_ടാർഗെറ്റ്_എൽവി = "$1"
lvremove -y "$REMOVE_TARGET_VG/$REMOVE_TARGET_LV"
സമന്വയം
}

ഫംഗ്ഷൻ removeall()
{
തീയതി_ഓഫ്‌സെറ്റ്="$3"
ഫിൽട്ടർ="$("$DATE_OFFSET" ഫിൽട്ടർ ചെയ്യുക)"
വായിക്കുമ്പോൾ -r സ്നാപ്പ്ഷോട്ട് ; ചെയ്യുക
"$SNAPSHOT" നീക്കം ചെയ്യുക
ചെയ്തു <(ലിസ്റ്റ് "$1" "$2" | grep "$FILTER")

}

(
കമാൻഡ്="$1"
ഷിഫ്റ്റ്

"$COMMAND" എന്ന കേസ്
"--സഹായം")
എക്കോ "സഹായം"
;;
"സഫിക്സ്")
സഫിക്സ്
;;
"ഫിൽട്ടർ")
"$1" ഫിൽട്ടർ ചെയ്യുക
;;
"ബാക്കപ്പ്")
കാത്തിരിക്കുക_ലോക്ക്_അല്ലെങ്കിൽ_ടെർമിനേറ്റ് ചെയ്യുക
ബാക്കപ്പ് "$1" "$2"
;;
"ലിസ്റ്റ്")
ലിസ്റ്റ് "$1" "$2"
;;
"തിണ്ടിഫ്")
തിൻഡിഫ് "$1" "$2" "$3"
;;
"തിൻസിങ്ക്")
തിൻസിങ്ക് "$1" "$2" "$3" "$4"
;;
"പരിശോധിക്കുക")
കാത്തിരിക്കുക_ലോക്ക്_അല്ലെങ്കിൽ_ടെർമിനേറ്റ് ചെയ്യുക
"$1" "$2" പരിശോധിക്കുക
;;
"പുനഃസമന്വയിപ്പിക്കുക")
കാത്തിരിക്കുക_ലോക്ക്_അല്ലെങ്കിൽ_ടെർമിനേറ്റ് ചെയ്യുക
"$1" "$2" പുനഃസമന്വയിപ്പിക്കുക
;;
"നീക്കം ചെയ്യുക")
കാത്തിരിക്കുക_ലോക്ക്_അല്ലെങ്കിൽ_ടെർമിനേറ്റ് ചെയ്യുക
"$1" നീക്കം ചെയ്യുക
;;
"എല്ലാം നീക്കം ചെയ്യുക")
കാത്തിരിക്കുക_ലോക്ക്_അല്ലെങ്കിൽ_ടെർമിനേറ്റ് ചെയ്യുക
"$1" "$2" "$3" എല്ലാം നീക്കം ചെയ്യുക
;;
*)
"ഒന്നുമില്ല.." എന്ന് പ്രതിധ്വനിക്കുക.
;;
സി
) 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="$(റിയൽപാത്ത് $0)"
SCRIPT_DIR="$(ഡയറക്ട് നാമം $SCRIPT_FILE)"
SCRIPT_NAME="$(ബേസ് നെയിം -s .sh $SCRIPT_FILE)"

ബാക്കപ്പ്_സ്ക്രിപ്റ്റ്="$SCRIPT_DIR/lvm-thin-backup.sh"
RETENTION="-60 ദിവസം"

ലിനക്സ്-ഡെവലപ്പർ $BACKUP_SCRIPT ബാക്കപ്പ് ഇമേജുകൾ
$BACKUP_SCRIPT ബാക്കപ്പ് ചിത്രങ്ങൾ win8
$BACKUP_SCRIPT ബാക്കപ്പ് ഇമേജുകൾ win8-data
#തുടങ്ങിയവ

$BACKUP_SCRIPT ലിനക്സ്-ഡെവലപ്മെന്റ് "$RETENTION" ലെ എല്ലാ ചിത്രങ്ങളും നീക്കം ചെയ്യുക.
$BACKUP_SCRIPT എല്ലാ ചിത്രങ്ങളും നീക്കം ചെയ്യുക win8 "$RETENTION"
$BACKUP_SCRIPT എല്ലാ ചിത്രങ്ങളും നീക്കം ചെയ്യുക win8-data "$RETENTION"
#തുടങ്ങിയവ

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

#സമയം /root/lvm-thin-backup/cron-daily.sh
യഥാർത്ഥ 1 മി 2,710 സെ
ഉപയോക്താവ് 0m12,721s
sys 0m6,671s

#ls -al /ബാക്കപ്പ്/btrfs/ബാക്ക്/റിമോട്ട്/*
/ബാക്കപ്പ്/btrfs/ബാക്ക്/റിമോട്ട്/ബൂട്ട്:
ആകെ 0
drwxr-xr-x 1 റൂട്ട് റൂട്ട് 1260 മാർച്ച് 26 09:11 .
drwxr-xr-x 1 റൂട്ട് റൂട്ട് 16 മാർച്ച് 6 09:30 ..
drwxr-xr-x 1 റൂട്ട് റൂട്ട് 322 മാർച്ച് 26 02:00 .@base
drwxr-xr-x 1 റൂട്ട് റൂട്ട് 516 മാർച്ച് 6 09:39 .@snap.2020-03-06-09-39-37
drwxr-xr-x 1 റൂട്ട് റൂട്ട് 516 മാർച്ച് 6 09:39 .@snap.2020-03-06-09-39-57
...
/ബാക്കപ്പ്/btrfs/ബാക്ക്/റിമോട്ട്/റൂട്ട്:
ആകെ 0
drwxr-xr-x 1 റൂട്ട് റൂട്ട് 2820 മാർച്ച് 26 09:11 .
drwxr-xr-x 1 റൂട്ട് റൂട്ട് 16 മാർച്ച് 6 09:30 ..
drwxr-xr-x 1 റൂട്ട് റൂട്ട് 240 മാർച്ച് 26 09:11 @.@base
drwxr-xr-x 1 റൂട്ട് റൂട്ട് മാർച്ച് 22 26 09:11 @home.@base
drwxr-xr-x 1 റൂട്ട് റൂട്ട് മാർച്ച് 22 6 09:39 @home.@snap.2020-03-06-09-39-35
drwxr-xr-x 1 റൂട്ട് റൂട്ട് മാർച്ച് 22 6 09:39 @home.@snap.2020-03-06-09-39-57
...
drwxr-xr-x 1 റൂട്ട് റൂട്ട് മാർച്ച് 240 6 09:39 @.@snap.2020-03-06-09-39-26
drwxr-xr-x 1 റൂട്ട് റൂട്ട് മാർച്ച് 240 6 09:39 @.@snap.2020-03-06-09-39-56
...

#lvs -olv_name,lv_size ഇമേജുകൾ && lvs -olv_name,lv_size ബാക്കപ്പ്
എൽവി എൽഎസ്ഐസെ
ലിനക്സ്-ഡെവലപ്പ്മെന്റ് 128,00 ഗ്രാം
ലിനക്സ്-ഡെവ്.ബേസ് 128,00 ഗ്രാം
നേർത്ത പൂൾ 1,38t
വിൻ8 128,00 ഗ്രാം
win8-ഡാറ്റ 2,00t
win8-data.base 2,00t - ഡെവലപ്പർമാർക്കുള്ള ഡാറ്റാബേസ്
win8.base 128,00 ഗ്രാം
എൽവി എൽഎസ്ഐസെ
ബാക്കപ്പ് 256,00 ഗ്രാം
ഇമേജസ്-ലിനക്സ്-ഡെവ്.ബേസ് 128,00 ഗ്രാം
images-linux-dev.snap.2020-03-08-10-09-11 128,00g
images-linux-dev.snap.2020-03-08-10-09-25 128,00g
...
ഇമേജസ്-വിൻ8-ഡാറ്റ.ബേസ് 2,00ടി
images-win8-data.snap.2020-03-16-14-11-55 2,00t
images-win8-data.snap.2020-03-16-14-19-50 2,00t
...
ഇമേജസ്-വിൻ8.ബേസ് 128,00 ഗ്രാം
images-win8.snap.2020-03-17-04-51-46 128,00g
images-win8.snap.2020-03-18-03-02-49 128,00g
...
തിൻ-പൂൾ <2,09t

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

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

പി.എസ്

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

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