តើ LVM និង Matryoshka មានអ្វីខ្លះដូចគ្នា?

ថ្ងៃដ៏ល្អ។
ខ្ញុំចង់ចែករំលែកជាមួយសហគមន៍នូវបទពិសោធន៍ជាក់ស្តែងរបស់ខ្ញុំក្នុងការកសាងប្រព័ន្ធផ្ទុកទិន្នន័យសម្រាប់ KVM ដោយប្រើ md RAID + LVM ។

កម្មវិធីនឹងរួមបញ្ចូលៈ

• ការកសាង md RAID 1 ពី NVMe SSD ។
• ការផ្គុំ md RAID 6 ពី SATA SSD និងដ្រាយធម្មតា។
• លក្ខណៈពិសេសនៃប្រតិបត្តិការ TRIM/DISCARD នៅលើ SSD RAID 1/6 ។
• ការបង្កើតអារេ md RAID 1/6 ដែលអាចចាប់ផ្តើមបាននៅលើសំណុំទូទៅនៃថាស។
• ការដំឡើងប្រព័ន្ធនៅលើ NVMe RAID 1 នៅពេលដែលមិនមានការគាំទ្រ NVMe នៅក្នុង BIOS ។
• ការប្រើប្រាស់ឃ្លាំងសម្ងាត់ LVM និង LVM ស្តើង។
• ការប្រើប្រាស់រូបថត BTRFS និងផ្ញើ / ទទួលសម្រាប់ការបម្រុងទុក។
• ការប្រើប្រាស់រូបថតស្តើង LVM និង thin_delta សម្រាប់ការបម្រុងទុករចនាប័ទ្ម BTRFS ។

ប្រសិនបើអ្នកចាប់អារម្មណ៍សូមមើលឆ្មា។

សេចក្តីថ្លែងការណ៍

អ្នក​និពន្ធ​មិន​ទទួល​ខុស​ត្រូវ​ណា​មួយ​ចំពោះ​ផល​វិបាក​នៃ​ការ​ប្រើ ឬ​មិន​ប្រើ​សម្ភារ/ឧទាហរណ៍/កូដ/ព័ត៌មាន​ជំនួយ/ទិន្នន័យ​ពី​អត្ថបទ​នេះ​ទេ។ តាមរយៈការអាន ឬប្រើប្រាស់សម្ភារៈនេះតាមមធ្យោបាយណាមួយ អ្នកទទួលខុសត្រូវចំពោះលទ្ធផលទាំងអស់នៃសកម្មភាពទាំងនេះ។ ផលវិបាកដែលអាចកើតមានរួមមាន៖

• NVMe SSDs ចៀនបំពង។
• បានប្រើទាំងស្រុងនូវធនធាននៃការកត់ត្រា និងការបរាជ័យនៃដ្រាយ SSD ។
• ការបាត់បង់ពេញលេញនៃទិន្នន័យទាំងអស់នៅលើដ្រាយទាំងអស់រួមទាំងច្បាប់ចម្លងបម្រុងទុក។
• ផ្នែករឹងកុំព្យូទ័រមានបញ្ហា។
• ខ្ជះខ្ជាយពេលវេលា សរសៃប្រសាទ និងលុយ។
• ផលវិបាកផ្សេងទៀតដែលមិនត្រូវបានរាយខាងលើ។

ជាតិដែក

ដែលអាចប្រើបានគឺ៖

Motherboard ចាប់ពីឆ្នាំ 2013 ជាមួយនឹងបន្ទះឈីប Z87 ពេញលេញជាមួយនឹង Intel Core i7 / Haswell ។

• ឧបករណ៍ដំណើរការ 4 ស្នូល 8 ខ្សែស្រឡាយ
• RAM 32 GB DDR3
• 1 x 16 ឬ 2 x 8 PCIe 3.0
• 1 x 4 + 1 x 1 PCIe 2.0
• ឧបករណ៍ភ្ជាប់ SATA 6 6 x 3 GBps

អាដាប់ទ័រ SAS LSI SAS9211-8I បានបញ្ចេញពន្លឺទៅជារបៀប IT / HBA ។ កម្មវិធីបង្កប់ដែលបើកដំណើរការ RAID ត្រូវបានជំនួសដោយចេតនាជាមួយកម្មវិធីបង្កប់ HBA ដើម្បី៖

1. អ្នកអាចបោះអាដាប់ទ័រនេះចេញនៅពេលណាក៏បាន ហើយជំនួសវាដោយឧបករណ៍ផ្សេងទៀតដែលអ្នកបានឆ្លងកាត់។
2. TRIM/Discard ដំណើរការជាធម្មតានៅលើថាស ព្រោះ... នៅក្នុងកម្មវិធីបង្កប់ RAID ពាក្យបញ្ជាទាំងនេះមិនត្រូវបានគាំទ្រទាល់តែសោះ ហើយ HBA ជាទូទៅមិនខ្វល់ពីអ្វីដែលពាក្យបញ្ជាត្រូវបានបញ្ជូននៅលើឡានក្រុងនោះទេ។

ថាសរឹង - 8 បំណែកនៃ HGST Travelstar 7K1000 ដែលមានសមត្ថភាព 1 TB ក្នុងទម្រង់ 2.5 ដូចជាសម្រាប់កុំព្យូទ័រយួរដៃ។ ដ្រាយទាំងនេះពីមុននៅក្នុងអារេ RAID 6 ។ ពួកគេក៏នឹងមានការប្រើប្រាស់នៅក្នុងប្រព័ន្ធថ្មីផងដែរ។ ដើម្បីរក្សាទុកការបម្រុងទុកមូលដ្ឋាន។

បន្ថែម៖

6 បំណែក SATA SSD ម៉ូដែល Samsung 860 QVO 2TB ។ SSDs ទាំងនេះតម្រូវឱ្យមានទំហំធំ វត្តមាននៃឃ្លាំងសម្ងាត់ SLC ភាពជឿជាក់ និងតម្លៃទាបត្រូវបានគេចង់បាន។ ការគាំទ្រសម្រាប់ការបោះបង់/សូន្យត្រូវបានទាមទារ ដែលត្រូវបានពិនិត្យដោយបន្ទាត់ក្នុង dmesg៖

kernel: ata1.00: Enabling discard_zeroes_data

2 បំណែកនៃ NVMe SSD ម៉ូដែល Samsung SSD 970 EVO 500GB ។

សម្រាប់ SSDs ទាំងនេះ ល្បឿនអាន/សរសេរចៃដន្យ និងសមត្ថភាពធនធានសម្រាប់តម្រូវការរបស់អ្នកគឺសំខាន់។ វិទ្យុសកម្មសម្រាប់ពួកគេ។ ចាំបាច់។ ដាច់ខាត។ បើមិនដូច្នេះទេ ចៀនវារហូតដល់ក្រៀម កំឡុងពេលធ្វើសមកាលកម្ម RAID ដំបូង។

អាដាប់ទ័រ StarTech PEX8M2E2 សម្រាប់ 2 x NVMe SSD ដែលបានដំឡើងនៅក្នុងរន្ធ PCIe 3.0 8x ។ នេះម្តងទៀតគ្រាន់តែជា HBA ប៉ុន្តែសម្រាប់ NVMe ។ វាខុសគ្នាពីអាដាប់ទ័រដែលមានតំលៃថោកដែលវាមិនតម្រូវឱ្យមានការគាំទ្រ PCIe bifurcation ពី motherboard ដោយសារតែវត្តមាននៃកុងតាក់ PCIe ដែលភ្ជាប់មកជាមួយ។ វានឹងដំណើរការសូម្បីតែនៅក្នុងប្រព័ន្ធបុរាណបំផុតជាមួយ PCIe ទោះបីជាវាជារន្ធ x1 PCIe 1.0 ក៏ដោយ។ តាមធម្មជាតិក្នុងល្បឿនសមរម្យ។ មិនមាន RAIDs នៅទីនោះទេ។ មិនមាន BIOS ដែលមានស្រាប់នៅលើយន្តហោះទេ។ ដូច្នេះ ប្រព័ន្ធរបស់អ្នកនឹងមិនអាចរៀនចាប់ផ្ដើមជាមួយ NVMe បានទេ មិនសូវធ្វើ NVMe RAID អរគុណចំពោះឧបករណ៍នេះ។

សមាសធាតុនេះគឺដោយសារតែវត្តមានរបស់ 8x PCIe 3.0 ឥតគិតថ្លៃតែមួយគត់នៅក្នុងប្រព័ន្ធ ហើយប្រសិនបើមានរន្ធដោតឥតគិតថ្លៃចំនួន 2 នោះ វាអាចត្រូវបានជំនួសដោយងាយស្រួលជាមួយ PEX4M2E1 ឬ analogues ពីរកាក់ដែលអាចទិញបានគ្រប់ទីកន្លែងក្នុងតម្លៃ 600 rubles ។

ការបដិសេធគ្រប់ប្រភេទនៃ Hardware ឬ Chipset/BIOS RAIDs ដែលភ្ជាប់មកជាមួយត្រូវបានធ្វើឡើងដោយចេតនា ដើម្បីអាចជំនួសប្រព័ន្ធទាំងមូលទាំងស្រុង លើកលែងតែ SSD/HDD ខ្លួនឯង ខណៈពេលដែលរក្សាទិន្នន័យទាំងអស់។ តាមឧត្ដមគតិ ដូច្នេះអ្នកអាចរក្សាទុកសូម្បីតែប្រព័ន្ធប្រតិបត្តិការដែលបានដំឡើងនៅពេលផ្លាស់ទីទៅផ្នែករឹងថ្មីទាំងស្រុង/ខុសគ្នា។ រឿងចំបងគឺថាមានច្រក SATA និង PCIe ។ វាដូចជាស៊ីឌីបន្តផ្ទាល់ ឬដ្រាយវ៍ពន្លឺដែលអាចចាប់ផ្តើមបាន មានតែលឿន និងសំពីងសំពោងបន្តិច។

ការលេងសើចបើមិនដូច្នេះទេ អ្នកដឹងថាមានអ្វីកើតឡើង - ពេលខ្លះអ្នកត្រូវការបន្ទាន់ដើម្បីយកអារេទាំងមូលជាមួយអ្នកដើម្បីយកទៅឆ្ងាយ។ ប៉ុន្តែខ្ញុំមិនចង់បាត់បង់ទិន្នន័យទេ។ ដើម្បីធ្វើដូច្នេះ ប្រព័ន្ធផ្សព្វផ្សាយដែលបានរៀបរាប់ទាំងអស់មានទីតាំងយ៉ាងងាយស្រួលនៅលើស្លាយក្នុង 5.25 bays នៃករណីស្តង់ដារ។

ជាការប្រសើរណាស់ ហើយជាការពិតណាស់ សម្រាប់ការពិសោធន៍ជាមួយវិធីសាស្រ្តផ្សេងគ្នានៃឃ្លាំងសម្ងាត់ SSD នៅក្នុងលីនុច។

ការវាយឆ្មក់ផ្នែករឹងគឺគួរឱ្យធុញ។ បើក​វា។ វាដំណើរការឬមិនដំណើរការ។ ហើយជាមួយ mdadm តែងតែមានជម្រើស។

សូហ្វវែរ

ពីមុន Debian 8 Jessie ត្រូវបានដំឡើងនៅលើ Hardware ដែលនៅជិត EOL។ RAID 6 ត្រូវបានផ្គុំពី HDDs ដែលបានរៀបរាប់ខាងលើ ផ្គូផ្គងជាមួយ LVM ។ វាដំណើរការម៉ាស៊ីននិម្មិតក្នុង kvm/libvirt។

ដោយសារតែ អ្នកនិពន្ធមានបទពិសោធន៍សមស្របក្នុងការបង្កើតដ្រាយវ៍ពន្លឺ SATA/NVMe ដែលអាចចាប់ផ្តើមបាន ហើយដើម្បីកុំឱ្យខូចគំរូ apt ធម្មតា អ៊ូប៊ុនទូ 18.04 ត្រូវបានជ្រើសរើសជាប្រព័ន្ធគោលដៅដែលមានស្ថេរភាពគ្រប់គ្រាន់រួចហើយ ប៉ុន្តែនៅតែមានរយៈពេល 3 ឆ្នាំ។ ការគាំទ្រនាពេលអនាគត។

ប្រព័ន្ធដែលបានរៀបរាប់មានកម្មវិធីបញ្ជាផ្នែករឹងទាំងអស់ដែលយើងត្រូវការចេញពីប្រអប់។ យើងមិនត្រូវការកម្មវិធីភាគីទីបី ឬកម្មវិធីបញ្ជាទេ។

កំពុងរៀបចំដំឡើង

ដើម្បីដំឡើងប្រព័ន្ធ យើងត្រូវការ Ubuntu Desktop Image ។ ប្រព័ន្ធម៉ាស៊ីនមេមានកម្មវិធីដំឡើងដ៏ខ្លាំងក្លាមួយចំនួនដែលបង្ហាញពីភាពឯករាជ្យហួសហេតុដែលមិនអាចបិទបានដោយការរុញភាគថាសប្រព័ន្ធ UEFI ទៅលើថាសមួយដែលធ្វើឱ្យខូចសោភ័ណភាពទាំងអស់។ ដូច្នោះហើយវាត្រូវបានដំឡើងតែនៅក្នុងរបៀប UEFI ប៉ុណ្ណោះ។ មិនផ្តល់ជម្រើសណាមួយឡើយ។

យើងមិនសប្បាយចិត្តនឹងរឿងនេះទេ។

ហេតុអ្វី?ជាអកុសល UEFI boot គឺមានភាពឆបគ្នាយ៉ាងលំបាកជាមួយនឹងកម្មវិធី RAID boot ព្រោះ... គ្មាននរណាម្នាក់ផ្តល់ឱ្យយើងនូវការកក់ទុកសម្រាប់ភាគថាស UEFI ESP ទេ។ មានរូបមន្តលើបណ្តាញដែលស្នើឱ្យដាក់ភាគថាស ESP នៅលើ flash drive នៅក្នុងរន្ធ USB ប៉ុន្តែនេះគឺជាចំណុចបរាជ័យ។ មានរូបមន្តប្រើប្រាស់កម្មវិធី mdadm RAID 1 ជាមួយនឹងទិន្នន័យមេតាកំណែ 0.9 ដែលមិនរារាំង UEFI BIOS ពីការមើលឃើញភាគថាសនេះ ប៉ុន្តែវារស់នៅរហូតដល់ពេលរីករាយនៅពេលដែល BIOS ឬប្រព័ន្ធប្រតិបត្តិការផ្នែករឹងផ្សេងទៀតសរសេរអ្វីមួយទៅ ESP ហើយភ្លេចធ្វើសមកាលកម្មវាទៅផ្សេងទៀត កញ្ចក់។

លើសពីនេះទៀត UEFI boot អាស្រ័យលើ NVRAM ដែលនឹងមិនផ្លាស់ទីជាមួយឌីសទៅប្រព័ន្ធថ្មីទេព្រោះ គឺជាផ្នែកមួយនៃ motherboard ។

ដូច្នេះ យើងនឹងមិនបង្កើតកង់ថ្មីឡើងវិញទេ។ យើង​មាន​កង់​របស់​ជីតា​ដែល​ត្រៀម​រួច​ជា​ស្រេច​ហើយ​ដែល​បាន​សាកល្បង​ពេល​នេះ ដែល​ឥឡូវ​គេ​ហៅថា Legacy/BIOS boot ដែល​មាន​ឈ្មោះ​មោទនភាព​នៃ CSM នៅ​លើ​ប្រព័ន្ធ​ដែល​ត្រូវ​គ្នា​នឹង UEFI។ យើងគ្រាន់តែយកវាចេញពីធ្នើ រំអិលវា បូមសំបកកង់ ហើយជូតវាដោយក្រណាត់សើម។

កំណែផ្ទៃតុរបស់ Ubuntu ក៏មិនអាចដំឡើងបានត្រឹមត្រូវជាមួយកម្មវិធី Legacy bootloader ដែរ ប៉ុន្តែនៅទីនេះ ដូចដែលពួកគេនិយាយ យ៉ាងហោចណាស់មានជម្រើស។

ដូច្នេះហើយ យើងប្រមូល hardware និងផ្ទុកប្រព័ន្ធពី Ubuntu Live flash drive ដែលអាចចាប់ផ្តើមបាន។ យើងនឹងត្រូវទាញយកកញ្ចប់ ដូច្នេះយើងនឹងរៀបចំបណ្តាញដែលដំណើរការសម្រាប់អ្នក។ ប្រសិនបើវាមិនដំណើរការទេ អ្នកអាចផ្ទុកកញ្ចប់ចាំបាច់ទៅ flash drive ជាមុន។

យើងចូលទៅក្នុងបរិស្ថាន Desktop បើកដំណើរការកម្មវិធីត្រាប់តាមស្ថានីយ ហើយបិទយើងទៅ៖

#sudo bash

យ៉ាងម៉េច…?បន្ទាត់ខាងលើគឺជាគន្លឹះ Canonical សម្រាប់ holiwars អំពី sudo ។ គ ខоឱកាសកាន់តែច្រើនមកដល់ហើយ។оការទទួលខុសត្រូវធំជាង។ សំណួរគឺថាតើអ្នកអាចយកវាដោយខ្លួនឯងបាន។ មនុស្សជាច្រើនគិតថាការប្រើ sudo នៅក្នុងវិធីនេះគឺយ៉ាងហោចណាស់មិនប្រុងប្រយ័ត្ន។ ទោះយ៉ាងណាក៏ដោយ៖

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

ហេតុអ្វីមិន ZFS...?នៅពេលដែលយើងដំឡើងកម្មវិធីនៅលើកុំព្យូទ័ររបស់យើង យើងផ្តល់ប្រាក់កម្ចីយ៉ាងសំខាន់ដល់អ្នកបង្កើតកម្មវិធីនេះដើម្បីជំរុញ។
នៅពេលដែលយើងជឿជាក់លើកម្មវិធីនេះជាមួយនឹងសុវត្ថិភាពនៃទិន្នន័យរបស់យើង យើងដកប្រាក់កម្ចីស្មើនឹងតម្លៃនៃការស្ដារទិន្នន័យនេះឡើងវិញ ដែលយើងនឹងត្រូវសងនៅថ្ងៃណាមួយ។

តាមទស្សនៈនេះ ZFS គឺជារថយន្ត Ferrari ហើយ mdadm+lvm គឺដូចជាកង់។

តាមការយល់ឃើញ អ្នកនិពន្ធចូលចិត្តខ្ចីកង់ដោយផ្តល់ឥណទានដល់បុគ្គលដែលមិនស្គាល់ ជំនួសឱ្យរថយន្ត Ferrari ។ នៅទីនោះតម្លៃនៃបញ្ហាគឺមិនខ្ពស់ទេ។ មិនចាំបាច់មានសិទ្ធិទេ។ សាមញ្ញជាងច្បាប់ចរាចរណ៍។ ចំណតរថយន្តគឺឥតគិតថ្លៃ។ សមត្ថភាពឆ្លងប្រទេសគឺប្រសើរជាង។ អ្នកតែងតែអាចភ្ជាប់ជើងទៅនឹងកង់ ហើយអ្នកអាចជួសជុលកង់ដោយដៃរបស់អ្នកផ្ទាល់។

ហេតុអ្វី BTRFS...?ដើម្បីចាប់ផ្ដើមប្រព័ន្ធប្រតិបត្តិការ យើងត្រូវការប្រព័ន្ធឯកសារដែលត្រូវបានគាំទ្រនៅក្នុង Legacy/BIOS GRUB ចេញពីប្រអប់ ហើយក្នុងពេលតែមួយគាំទ្រការថតរូបផ្ទាល់។ យើងនឹងប្រើវាសម្រាប់ភាគថាស /boot ។ លើសពីនេះទៀតអ្នកនិពន្ធចូលចិត្តប្រើ FS នេះសម្រាប់ / (root) ដោយកុំភ្លេចចំណាំថាសម្រាប់កម្មវិធីផ្សេងទៀតអ្នកអាចបង្កើតភាគថាសដាច់ដោយឡែកនៅលើ LVM ហើយម៉ោនវានៅក្នុងថតចាំបាច់។

យើងនឹងមិនរក្សាទុករូបភាពណាមួយនៃម៉ាស៊ីននិម្មិត ឬមូលដ្ឋានទិន្នន័យនៅលើ FS នេះទេ។
FS នេះនឹងត្រូវបានប្រើដើម្បីបង្កើតរូបថតនៃប្រព័ន្ធដោយមិនបិទវា ហើយបន្ទាប់មកផ្ទេររូបថតទាំងនេះទៅថាសបម្រុងទុកដោយប្រើការផ្ញើ/ទទួល។

លើសពីនេះ អ្នកនិពន្ធជាទូទៅចូលចិត្តរក្សាអប្បរមានៃកម្មវិធីដោយផ្ទាល់នៅលើផ្នែករឹង ហើយដំណើរការកម្មវិធីផ្សេងទៀតទាំងអស់នៅក្នុងម៉ាស៊ីននិម្មិតដោយប្រើប្រាស់អ្វីៗដូចជាបញ្ជូនបន្ត GPUs និង PCI-USB Host controllers ទៅ KVM តាមរយៈ IOMMU ។

អ្វី​ដែល​នៅ​សេសសល់​តែ​មួយ​គត់​នៅ​លើ hardware គឺ​ការ​ផ្ទុក​ទិន្នន័យ ការ​និម្មិត និង​ការ​បម្រុង​ទុក។

ប្រសិនបើអ្នកទុកចិត្ត ZFS ច្រើនជាងនេះ ជាគោលការណ៍សម្រាប់កម្មវិធីដែលបានបញ្ជាក់ ពួកគេអាចផ្លាស់ប្តូរបាន។

ទោះជាយ៉ាងណាក៏ដោយ អ្នកនិពន្ធមិនអើពើដោយចេតនាចំពោះមុខងារឆ្លុះ / RAID ដែលភ្ជាប់មកជាមួយ និងលក្ខណៈពិសេសដែលលែងត្រូវការគ្នាដែល ZFS, BRTFS និង LVM មាន។

ជាអំណះអំណាងបន្ថែម BTRFS មានសមត្ថភាពបង្វែរការសរសេរចៃដន្យទៅជាបន្តបន្ទាប់គ្នា ដែលមានឥទ្ធិពលវិជ្ជមានយ៉ាងខ្លាំងទៅលើល្បឿននៃការធ្វើសមកាលកម្មនៃរូបថត / ការបម្រុងទុកនៅលើ HDD ។

តោះស្កេនឧបករណ៍ទាំងអស់ឡើងវិញ៖

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

តោះមើលជុំវិញ៖

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


ប្លង់ឌីស

អិនអេមអេសអេស

ប៉ុន្តែ​យើង​នឹង​មិន​សម្គាល់​ពួកគេ​តាម​វិធី​ណា​មួយ​ឡើយ។ ដូចគ្នាទាំងអស់ BIOS របស់យើងមិនឃើញដ្រាយទាំងនេះទេ។ ដូច្នេះ ពួកគេនឹងចូលទៅ RAID កម្មវិធីទាំងស្រុង។ យើងនឹងមិនបង្កើតផ្នែកនៅទីនោះទេ។ ប្រសិនបើអ្នកចង់ធ្វើតាម "canon" ឬ "ចម្បង" បង្កើតភាគធំមួយដូចជា HDD ។

អេសអេសអេដឌីអេស

មិនចាំបាច់បង្កើតអ្វីពិសេសនៅទីនេះទេ។ យើងនឹងបង្កើតផ្នែកមួយសម្រាប់អ្វីគ្រប់យ៉ាង។ យើងនឹងបង្កើតភាគថាសព្រោះ BIOS ឃើញថាសទាំងនេះ ហើយថែមទាំងអាចព្យាយាមចាប់ផ្ដើមពីពួកវាទៀតផង។ យើងនឹងដំឡើង GRUB នៅលើថាសទាំងនេះនៅពេលក្រោយដើម្បីឱ្យប្រព័ន្ធអាចធ្វើវាបានភ្លាមៗ។

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

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


SATA SSD

នេះគឺជាកន្លែងដែលអ្វីដែលគួរឱ្យចាប់អារម្មណ៍សម្រាប់យើង។

ទីមួយ ដ្រាយរបស់យើងមានទំហំ 2 TB ។ វាស្ថិតនៅក្នុងជួរដែលអាចទទួលយកបានសម្រាប់ MBR ដែលជាអ្វីដែលយើងនឹងប្រើ។ បើចាំបាច់អាចត្រូវបានជំនួសដោយ GPT ។ ថាស GPT មានស្រទាប់ភាពឆបគ្នាដែលអនុញ្ញាតឱ្យប្រព័ន្ធដែលឆបគ្នាជាមួយ MBR ដើម្បីមើលភាគថាស 4 ដំបូង ប្រសិនបើពួកវាមានទីតាំងនៅក្នុង 2 តេរ៉ាបៃដំបូង។ រឿងចំបងគឺថាភាគថាសចាប់ផ្ដើមនិងភាគថាស bios_grub នៅលើថាសទាំងនេះគួរតែនៅដើមដំបូង។ វាថែមទាំងអនុញ្ញាតឱ្យអ្នកចាប់ផ្ដើមពីដ្រាយ GPT Legacy/BIOS ផងដែរ។

ប៉ុន្តែនេះមិនមែនជាករណីរបស់យើងទេ។

នៅទីនេះយើងនឹងបង្កើតផ្នែកពីរ។ ទីមួយនឹងមានទំហំ 1 GB ហើយប្រើសម្រាប់ RAID 1/boot។

ទីពីរ​នឹង​ត្រូវ​បាន​ប្រើ​សម្រាប់ RAID 6 ហើយ​នឹង​យក​ទំហំ​ទំនេរ​ដែល​នៅ​សល់​ទាំងអស់​លើក​លែង​តែ​សម្រាប់​តំបន់​ដែល​មិន​បាន​បែងចែក​តូច​នៅ​ខាង​ចុង​នៃ​ដ្រាយ។

តើ​តំបន់​ដែល​មិន​បាន​សម្គាល់​នេះ​ជា​អ្វី?យោងតាមប្រភពនៅលើបណ្តាញ SATA SSDs របស់យើងមាននៅលើឃ្លាំងសម្ងាត់ SLC ដែលអាចពង្រីកបានយ៉ាងស្វាហាប់ដែលមានទំហំចាប់ពី 6 ទៅ 78 ជីហ្គាបៃ។ យើងទទួលបាន 6 ជីហ្គាបៃ "ដោយឥតគិតថ្លៃ" ដោយសារតែភាពខុសគ្នារវាង "ជីហ្គាបៃ" និង "ជីប៊ីបៃ" នៅក្នុងសន្លឹកទិន្នន័យនៃដ្រាយ។ 72 ជីហ្គាបៃដែលនៅសល់ត្រូវបានបែងចែកពីទំហំដែលមិនប្រើ។

នៅទីនេះវាគួរតែត្រូវបានកត់សម្គាល់ថាយើងមានឃ្លាំងសម្ងាត់ SLC ហើយចន្លោះត្រូវបានកាន់កាប់ក្នុងរបៀប MLC 4 ប៊ីត។ ដែលសម្រាប់យើងមានប្រសិទ្ធភាពមានន័យថាសម្រាប់រាល់ទំហំទំនេរ 4 ជីហ្គាបៃ យើងនឹងទទួលបានឃ្លាំងសម្ងាត់ SLC ត្រឹមតែ 1 ជីហ្គាបៃប៉ុណ្ណោះ។

គុណ 72 ជីហ្គាបៃដោយ 4 និងទទួលបាន 288 ជីហ្គាបៃ។ នេះគឺជាទំហំទំនេរដែលយើងនឹងមិនសម្គាល់ដើម្បីអនុញ្ញាតឱ្យដ្រាយប្រើប្រាស់ពេញលេញនៃឃ្លាំងសម្ងាត់ SLC ។

ដូច្នេះ យើងនឹងទទួលបាននូវឃ្លាំងសម្ងាត់ SLC រហូតដល់ 312 ជីហ្គាបៃយ៉ាងមានប្រសិទ្ធភាព ពីដ្រាយសរុបចំនួនប្រាំមួយ។ ក្នុងចំណោមដ្រាយទាំងអស់ 2 នឹងត្រូវបានប្រើនៅក្នុង RAID សម្រាប់ការលែងត្រូវការតទៅទៀត។

ចំនួននៃឃ្លាំងសម្ងាត់នេះនឹងអនុញ្ញាតឱ្យយើងកម្រណាស់នៅក្នុងជីវិតពិតជួបប្រទះស្ថានភាពដែលការសរសេរមិនចូលទៅកាន់ឃ្លាំងសម្ងាត់។ នេះផ្តល់សំណងយ៉ាងល្អសម្រាប់គុណវិបត្តិដ៏ក្រៀមក្រំបំផុតនៃអង្គចងចាំ QLC - ល្បឿនសរសេរទាបបំផុតនៅពេលដែលទិន្នន័យត្រូវបានសរសេររំលងឃ្លាំងសម្ងាត់។ ប្រសិនបើការផ្ទុករបស់អ្នកមិនត្រូវគ្នានឹងបញ្ហានេះទេ ខ្ញុំសូមណែនាំឱ្យអ្នកគិតឱ្យច្បាស់ថាតើ SSD របស់អ្នកនឹងមានរយៈពេលប៉ុន្មាននៅក្រោមបន្ទុកបែបនេះ ដោយគិតគូរពី TBW ពីសន្លឹកទិន្នន័យ។

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

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


ការបង្កើតអារេ

ដំបូងយើងត្រូវប្តូរឈ្មោះម៉ាស៊ីន។ នេះគឺចាំបាច់ពីព្រោះឈ្មោះម៉ាស៊ីនគឺជាផ្នែកមួយនៃឈ្មោះអារេនៅកន្លែងណាមួយនៅខាងក្នុង mdadm ហើយប៉ះពាល់ដល់អ្វីមួយនៅកន្លែងណាមួយ។ ជាការពិតណាស់ អារេអាចត្រូវបានប្តូរឈ្មោះនៅពេលក្រោយ ប៉ុន្តែនេះគឺជាជំហានមិនចាំបាច់។

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


អិនអេមអេសអេស

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

ហេតុអ្វី-សន្មត់ថាស្អាត...?ដើម្បីជៀសវាងការចាប់ផ្តើមអារេ។ សម្រាប់កម្រិត RAID ទាំង 1 និង 6 នេះគឺត្រឹមត្រូវ។ អ្វីគ្រប់យ៉ាងអាចដំណើរការដោយគ្មានការចាប់ផ្តើមប្រសិនបើវាជាអារេថ្មី។ លើសពីនេះទៅទៀត ការចាប់ផ្ដើមអារេ SSD នៅពេលបង្កើតគឺជាការខ្ជះខ្ជាយធនធាន TBW ។ យើងប្រើ TRIM/DISCARD ដែលជាកន្លែងដែលអាចធ្វើទៅបាននៅលើអារេ SSD ដែលបានជួបប្រជុំគ្នាដើម្បី "ចាប់ផ្តើម" ពួកវា។

សម្រាប់អារេ SSD, RAID 1 DISCARD ត្រូវបានគាំទ្រចេញពីប្រអប់។

សម្រាប់អារេ SSD RAID 6 DISCARD អ្នកត្រូវតែបើកវានៅក្នុងប៉ារ៉ាម៉ែត្រម៉ូឌុលខឺណែល។

នេះគួរតែត្រូវបានធ្វើលុះត្រាតែ SSDs ទាំងអស់ដែលប្រើក្នុងកម្រិត 4/5/6 អារេនៅក្នុងប្រព័ន្ធនេះមានការគាំទ្រដំណើរការសម្រាប់ discard_zeroes_data។ ពេលខ្លះអ្នកជួបប្រទះនឹងដ្រាយចម្លែកដែលប្រាប់ខឺណែលថាមុខងារនេះត្រូវបានគាំទ្រ ប៉ុន្តែតាមពិតវាមិននៅទីនោះទេ ឬមុខងារមិនដំណើរការជានិច្ច។ នៅពេលនេះ ការគាំទ្រមានស្ទើរតែគ្រប់ទីកន្លែង ទោះបីជាយ៉ាងណាក៏ដោយ មានដ្រាយវ៍ចាស់ និងកម្មវិធីបង្កប់ដែលមានកំហុស។ សម្រាប់ហេតុផលនេះ ការគាំទ្រ DISCARD ត្រូវបានបិទតាមលំនាំដើមសម្រាប់ RAID 6 ។

យកចិត្តទុកដាក់ ពាក្យបញ្ជាខាងក្រោមនឹងបំផ្លាញទិន្នន័យទាំងអស់នៅលើដ្រាយ NVMe ដោយ "ចាប់ផ្តើម" អារេជាមួយ "សូន្យ" ។

#blkdiscard /dev/md0

ប្រសិនបើមានអ្វីមួយខុស សូមព្យាយាមបញ្ជាក់ជំហានមួយ។

#blkdiscard --step 65536 /dev/md0

SATA SSD

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

ហេតុអ្វីធំម្លេះ...?ការបង្កើនទំហំកំណាត់មានឥទ្ធិពលវិជ្ជមានទៅលើល្បឿននៃការអានចៃដន្យនៅក្នុងប្លុករហូតដល់ទំហំកំណាត់។ វាកើតឡើងដោយសារតែប្រតិបត្តិការមួយនៃទំហំសមស្រប ឬតូចជាងនេះអាចត្រូវបានបញ្ចប់ទាំងស្រុងនៅលើឧបករណ៍តែមួយ។ ដូច្នេះ IOPS ពីឧបករណ៍ទាំងអស់ត្រូវបានសង្ខេប។ យោងតាមស្ថិតិ 99% នៃ IO មិនលើសពី 512K ។

RAID 6 IOPS ក្នុងមួយសរសេរ តែងតែ តិចជាង ឬស្មើនឹង IOPS នៃដ្រាយមួយ។ នៅពេលដែលការអានចៃដន្យ IOPS អាចធំជាងដ្រាយមួយដងច្រើនដង ហើយនៅទីនេះទំហំប្លុកមានសារៈសំខាន់ណាស់។
អ្នកនិពន្ធមិនឃើញចំណុចក្នុងការព្យាយាមបង្កើនប្រសិទ្ធភាពប៉ារ៉ាម៉ែត្រដែលមិនល្អនៅក្នុង RAID 6 ដោយការរចនានោះទេ ហើយជំនួសមកវិញនូវអ្វីដែល RAID 6 ល្អនៅក្នុងនោះ។
យើងនឹងផ្តល់សំណងសម្រាប់ការសរសេរចៃដន្យមិនល្អនៃ RAID 6 ជាមួយនឹងឃ្លាំងសម្ងាត់ NVMe និងល្បិចផ្តល់ស្តើង។

យើងមិនទាន់បានបើក DISCARD សម្រាប់ RAID 6។ ដូច្នេះយើងនឹងមិន "ចាប់ផ្តើម" អារេនេះសម្រាប់ពេលនេះទេ។ យើងនឹងធ្វើវានៅពេលក្រោយ បន្ទាប់ពីដំឡើង OS។

អេសអេសអេដឌីអេស

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

LVM នៅលើ NVMe RAID

សម្រាប់ល្បឿន យើងចង់ដាក់ប្រព័ន្ធឯកសារ root នៅលើ NVMe RAID 1 ដែលជា /dev/md0 ។
ទោះជាយ៉ាងណាក៏ដោយ យើងនឹងនៅតែត្រូវការអារេដ៏លឿននេះសម្រាប់តម្រូវការផ្សេងទៀតដូចជា swap ទិន្នន័យមេតា និង LVM-cache និង LVM-thin metadata ដូច្នេះយើងនឹងបង្កើត LVM VG នៅលើអារេនេះ។

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

តោះបង្កើតភាគថាសសម្រាប់ប្រព័ន្ធឯកសារ root ។

#lvcreate -L 128G --name root root

តោះបង្កើត Partition សម្រាប់ប្តូរតាមទំហំ RAM។

#lvcreate -L 32G --name swap root

ការដំឡើង OS

សរុបមក យើងមានអ្វីគ្រប់យ៉ាងដែលចាំបាច់ក្នុងការដំឡើងប្រព័ន្ធ។

បើកដំណើរការអ្នកជំនួយការដំឡើងប្រព័ន្ធពីបរិស្ថាន Ubuntu Live ។ ការដំឡើងធម្មតា។ មានតែនៅដំណាក់កាលនៃការជ្រើសរើសថាសសម្រាប់ដំឡើងប៉ុណ្ណោះ អ្នកត្រូវបញ្ជាក់ដូចខាងក្រោម៖

• /dev/md1, - ចំណុចម៉ោន / boot, FS - BTRFS
• /dev/root/root (aka /dev/mapper/root-root), - ចំណុចម៉ោន / (root), FS - BTRFS
• /dev/root/swap (aka /dev/mapper/root-swap), - ប្រើជាភាគថាសស្វប
• ដំឡើងកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធនៅលើ /dev/sda

នៅពេលអ្នកជ្រើសរើស BTRFS ជាប្រព័ន្ធឯកសារ root កម្មវិធីដំឡើងនឹងបង្កើតភាគ BTRFS ពីរដោយស្វ័យប្រវត្តិដែលមានឈ្មោះថា "@" សម្រាប់ / (root) និង "@home" សម្រាប់ /home ។

តោះចាប់ផ្តើមដំឡើង...

ការដំឡើងនឹងបញ្ចប់ដោយប្រអប់ម៉ូឌុលដែលបង្ហាញពីកំហុសក្នុងការដំឡើងកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធ។ ជាអកុសល អ្នកនឹងមិនអាចចេញពីប្រអប់នេះដោយប្រើមធ្យោបាយស្តង់ដារ និងបន្តការដំឡើងបានទេ។ យើងចេញពីប្រព័ន្ធ ហើយចូលម្តងទៀត ដោយបញ្ចប់ដោយផ្ទៃតុ Ubuntu Live ស្អាត។ បើកស្ថានីយ ហើយម្តងទៀត៖

#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 ជាមុនសិន

តោះកែតម្រូវប៉ារ៉ាម៉ែត្រសម្រាប់ម៉ូឌុល RAID 6 ដើម្បីបើក TRIM/DISCARD៖

#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 RAIDs មិនធ្វើឱ្យដ្រាយវ៍របស់អ្នកមានភាពស្រទន់ទេ។ នេះជាការពិតជាពិសេសសម្រាប់ NVMe ។ (ចងចាំអំពីវិទ្យុសកម្ម? ខ្ញុំមិននិយាយលេងទេ)
• ហាមឃាត់ថាសពីការបញ្ឈប់ការបង្វិល spindle (HDD) តាមរយៈ APM និងកំណត់ពេលវេលានៃការគេងសម្រាប់ឧបករណ៍បញ្ជាថាសដល់ 7 ម៉ោង។ អ្នកអាចបិទ APM ទាំងស្រុងប្រសិនបើដ្រាយរបស់អ្នកអាចធ្វើបាន (-B 255) ។ ជាមួយនឹងតម្លៃលំនាំដើម ដ្រាយនឹងឈប់បន្ទាប់ពីប្រាំវិនាទី។ បន្ទាប់មក OS ចង់កំណត់ឃ្លាំងសម្ងាត់ថាសឡើងវិញ ថាសនឹងវិលម្តងទៀត ហើយអ្វីៗនឹងចាប់ផ្តើមម្តងទៀត។ ឌីសមានចំនួនអតិបរមាកំណត់នៃការបង្វិល spindle ។ វដ្តលំនាំដើមសាមញ្ញបែបនេះអាចសម្លាប់ថាសរបស់អ្នកយ៉ាងងាយស្រួលក្នុងរយៈពេលពីរបីឆ្នាំ។ មិនមែនថាសទាំងអស់ទទួលរងពីបញ្ហានេះទេ ប៉ុន្តែរបស់យើងគឺជា "កុំព្យូទ័រយួរដៃ" ជាមួយនឹងការកំណត់លំនាំដើមដែលសមស្រប ដែលធ្វើឱ្យ RAID មើលទៅដូចជា mini-MAID ។
• ដំឡើង readahead នៅលើថាស (បង្វិល) 1 megabyte - ពីរប្លុកជាប់គ្នា/កំណាត់ RAID 6
• បិទដំណើរការ readahead នៅលើអារេខ្លួនឯង។

តោះកែសម្រួល /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
ហេតុអ្វីបានជា​អញ្ចឹង..?យើងនឹងស្វែងរកភាគថាស /boot ដោយ UUID ។ ឈ្មោះអារេអាចផ្លាស់ប្តូរតាមទ្រឹស្តី។

យើងនឹងស្វែងរកផ្នែកដែលនៅសល់ដោយឈ្មោះ LVM នៅក្នុងសញ្ញាណ /dev/mapper/vg-lv ពីព្រោះ ពួកគេកំណត់អត្តសញ្ញាណភាគថាសយ៉ាងពិសេស។

យើងមិនប្រើ UUID សម្រាប់ LVM ទេព្រោះ UUID នៃបរិមាណ LVM និងរូបថតរបស់ពួកគេអាចដូចគ្នា។ម៉ោន /dev/mapper/root-root.. ពីរដង?បាទ។ យ៉ាង​ពិតប្រាកដ។ លក្ខណៈពិសេសរបស់ BTRFS ប្រព័ន្ធឯកសារនេះអាចត្រូវបានម៉ោនជាច្រើនដងជាមួយនឹង subvols ផ្សេងគ្នា។

ដោយសារលក្ខណៈពិសេសដូចគ្នានេះ ខ្ញុំសូមណែនាំកុំឱ្យបង្កើតរូបភាព LVM នៃបរិមាណ BTRFS សកម្ម។ អ្នកអាចទទួលបានការភ្ញាក់ផ្អើលនៅពេលអ្នកចាប់ផ្តើមឡើងវិញ។

តោះបង្កើត mdadm config ឡើងវិញ៖

#/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

តេ​ី​វា​ជា​អ្វី..?យើងបានបើកការពង្រីកដោយស្វ័យប្រវត្តិនៃអាងស្តើង LVM នៅពេលឈានដល់ 90% នៃទំហំដែលកាន់កាប់ដោយ 5% នៃបរិមាណ។

យើងបានបង្កើនចំនួនអតិបរមានៃប្លុកឃ្លាំងសម្ងាត់សម្រាប់ឃ្លាំងសម្ងាត់ LVM ។

យើងបានរារាំង LVM ពីការស្វែងរកបរិមាណ LVM (PV) នៅលើ៖

• ឧបករណ៍ដែលមានឃ្លាំងសម្ងាត់ LVM (cdata)
• ឧបករណ៍ដែលបានរក្សាទុកដោយប្រើឃ្លាំងសម្ងាត់ LVM ដោយឆ្លងកាត់ឃ្លាំងសម្ងាត់ ( _កូរីក)។ ក្នុងករណីនេះ ឧបករណ៍ដែលបានរក្សាទុកក្នុងឃ្លាំងសម្ងាត់ខ្លួនឯងនឹងនៅតែត្រូវបានស្កេនតាមរយៈឃ្លាំងសម្ងាត់ (គ្រាន់តែ )
• ឧបករណ៍ដែលមានផ្ទុកទិន្នន័យមេតាឃ្លាំងសម្ងាត់ LVM (cmeta)
• ឧបករណ៍ទាំងអស់នៅក្នុង VG ដែលមានរូបភាពឈ្មោះ។ នៅទីនេះយើងនឹងមានរូបភាពឌីសនៃម៉ាស៊ីននិម្មិត ហើយយើងមិនចង់ឱ្យ LVM នៅលើម៉ាស៊ីនដំណើរការបរិមាណដែលជាកម្មសិទ្ធិរបស់ OS ភ្ញៀវទេ។
• ឧបករណ៍ទាំងអស់នៅក្នុង VG ជាមួយនឹងការបម្រុងទុកឈ្មោះ។ នៅទីនេះយើងនឹងមានច្បាប់ចម្លងបម្រុងទុកនៃរូបភាពម៉ាស៊ីននិម្មិត។
• ឧបករណ៍ទាំងអស់ដែលឈ្មោះបញ្ចប់ដោយ "gpv" (បរិមាណរាងកាយភ្ញៀវ)

យើងបានបើកដំណើរការជំនួយ DISCARD នៅពេលបង្កើនទំហំទំនេរនៅលើ LVM VG។ ត្រូវ​ប្រុងប្រយ័ត្ន។ វានឹងធ្វើឱ្យការលុប LVs នៅលើ SSD ចំណាយពេលច្រើន។ ជាពិសេសនេះអនុវត្តចំពោះ SSD RAID 6។ ទោះជាយ៉ាងណាក៏ដោយ យោងតាមផែនការ យើងនឹងប្រើការផ្តល់ស្តើង ដូច្នេះវានឹងមិនរារាំងយើងទាល់តែសោះ។

តោះធ្វើបច្ចុប្បន្នភាពរូបភាព initramfs៖

#update-initramfs -u -k all

ដំឡើងនិងកំណត់រចនាសម្ព័ន្ធ grub:

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

តើថាសមួយណាដែលត្រូវជ្រើសរើស?អ្នក​ទាំង​អស់​គ្នា sd*. ប្រព័ន្ធត្រូវតែអាចចាប់ផ្ដើមពីដ្រាយ SATA ឬ SSD ដែលដំណើរការ។

ហេតុអ្វីបានជាគេបន្ថែម os-prober..?សម្រាប់ភាពឯករាជ្យហួសហេតុនិងដៃលេង។

វាមិនដំណើរការត្រឹមត្រូវទេ ប្រសិនបើ RAIDs ណាមួយស្ថិតក្នុងស្ថានភាពខូច។ វាព្យាយាមស្វែងរកប្រព័ន្ធប្រតិបត្តិការនៅលើភាគថាសដែលត្រូវបានប្រើនៅក្នុងម៉ាស៊ីននិម្មិតដែលកំពុងដំណើរការលើផ្នែករឹងនេះ។

ប្រសិនបើអ្នកត្រូវការ អ្នកអាចទុកវាចោលបាន ប៉ុន្តែត្រូវចងចាំទាំងអស់ខាងលើ។ ខ្ញុំ​សូម​ណែនាំ​ឱ្យ​រក​មើល​រូបមន្ត​សម្រាប់​កម្ចាត់​ដៃ​មិន​ស្អាត​តាម​អ៊ីនធឺណិត។

ជាមួយនេះយើងបានបញ្ចប់ការដំឡើងដំបូង។ វាដល់ពេលហើយដើម្បីចាប់ផ្ដើមប្រព័ន្ធប្រតិបត្តិការដែលបានដំឡើងថ្មី។ កុំភ្លេចយក Live CD/USB ដែលអាចចាប់ផ្តើមបាន។

#exit
#reboot

ជ្រើសរើស SATA SSDs ណាមួយជាឧបករណ៍ចាប់ផ្ដើម។

LVM នៅលើ SATA SSD

នៅចំណុចនេះ យើងបានចាប់ផ្ដើមប្រព័ន្ធប្រតិបត្តិការថ្មីរួចហើយ កំណត់រចនាសម្ព័ន្ធបណ្តាញ apt បើកកម្មវិធីត្រាប់តាមស្ថានីយ ហើយដំណើរការ៖

#sudo bash

សូមបន្ត។

"ចាប់ផ្តើម" អារេពី SATA SSD៖

#blkdiscard /dev/md2

ប្រសិនបើវាមិនដំណើរការទេ សាកល្បង៖

#blkdiscard --step 65536 /dev/md2
បង្កើត LVM VG នៅលើ SATA SSD៖

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

ហេតុអ្វី VG មួយទៀត..?តាមពិតយើងមាន VG ដែលមានឈ្មោះថា root រួចហើយ។ ហេតុអ្វីមិនបន្ថែមអ្វីគ្រប់យ៉ាងទៅក្នុង VG តែមួយ?

ប្រសិនបើមាន PV ជាច្រើននៅក្នុង VG បន្ទាប់មកដើម្បីឱ្យ VG ដំណើរការបានត្រឹមត្រូវ PV ទាំងអស់ត្រូវតែមានវត្តមាន (អនឡាញ)។ ករណីលើកលែងគឺ LVM RAID ដែលយើងមិនប្រើដោយចេតនា។

យើងពិតជាចង់បានថាប្រសិនបើមានការបរាជ័យ (អានការបាត់បង់ទិន្នន័យ) នៅលើអារេ RAID 6 ណាមួយនោះ ប្រព័ន្ធប្រតិបត្តិការនឹងចាប់ផ្ដើមជាធម្មតា ហើយផ្តល់ឱ្យយើងនូវឱកាសដើម្បីដោះស្រាយបញ្ហា។

ដើម្បីធ្វើដូចនេះនៅកម្រិតដំបូងនៃការអរូបី យើងនឹងញែកប្រភេទនៃ "ប្រព័ន្ធផ្សព្វផ្សាយ" រាងកាយនីមួយៗទៅជា VG ដាច់ដោយឡែកមួយ។

និយាយតាមបែបវិទ្យាសាស្ត្រ អារេ RAID ផ្សេងគ្នាជាកម្មសិទ្ធិរបស់ "ដែនភាពជឿជាក់" ផ្សេងៗគ្នា។ អ្នកមិនគួរបង្កើតចំណុចធម្មតាបន្ថែមនៃការបរាជ័យសម្រាប់ពួកគេដោយបញ្ចូលពួកវាទៅក្នុង VG តែមួយនោះទេ។

វត្តមានរបស់ LVM នៅកម្រិត "Hardware" នឹងអនុញ្ញាតឱ្យយើងកាត់បំណែកនៃ RAID arrays ផ្សេងៗគ្នាតាមអំពើចិត្តដោយផ្សំវាតាមវិធីផ្សេងៗគ្នា។ ឧទាហរណ៍ - រត់ ក្នុងពេលតែមួយ។ bcache + LVM ស្តើង bcache + BTRFS ឃ្លាំងសម្ងាត់ LVM + LVM ស្តើង ការកំណត់រចនាសម្ព័ន្ធ ZFS ស្មុគ្រស្មាញជាមួយឃ្លាំងសម្ងាត់ ឬល្បាយនរកផ្សេងទៀតដើម្បីសាកល្បងប្រៀបធៀបវាទាំងអស់។

នៅកម្រិត "Hardware" យើងនឹងមិនប្រើអ្វីផ្សេងក្រៅពីបរិមាណ LVM "ក្រាស់" ចាស់ល្អនោះទេ។ ការលើកលែងចំពោះច្បាប់នេះអាចជាភាគថាសបម្រុងទុក។

ខ្ញុំគិតថាមកដល់ពេលនេះ អ្នកអានជាច្រើនបានចាប់ផ្ដើមសង្ស័យអ្វីមួយអំពីតុក្កតាសំបុក។

LVM នៅលើ SATA HDD

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

VG ថ្មីទៀតហើយ..?យើងពិតជាចង់បានថា ប្រសិនបើអារេឌីសដែលយើងនឹងប្រើសម្រាប់ការបម្រុងទុកទិន្នន័យបរាជ័យ ប្រព័ន្ធប្រតិបត្តិការរបស់យើងនឹងបន្តដំណើរការជាធម្មតា ខណៈពេលដែលរក្សាការចូលប្រើទិន្នន័យដែលមិនបម្រុងទុកដូចធម្មតា។ ដូច្នេះ ដើម្បីជៀសវាងបញ្ហានៃការធ្វើឱ្យសកម្ម VG យើងបង្កើត VG ដាច់ដោយឡែក។

ការដំឡើងឃ្លាំងសម្ងាត់ LVM

តោះបង្កើត LV នៅលើ NVMe RAID 1 ដើម្បីប្រើវាជាឧបករណ៍ផ្ទុកទិន្នន័យ។

#lvcreate -L 70871154688B --name cache root

ហេតុអ្វីបានជាមានតិចម្ល៉េះ...?ការពិតគឺថា NVMe SSDs របស់យើងក៏មានឃ្លាំងសម្ងាត់ SLC ផងដែរ។ 4 ជីហ្គាបៃនៃ "ឥតគិតថ្លៃ" និង 18 ជីហ្គាបៃនៃថាមវន្តដោយសារតែទំហំទំនេរដែលបានកាន់កាប់នៅក្នុង MLC 3 ប៊ីត។ នៅពេលដែលឃ្លាំងសម្ងាត់នេះអស់ហើយ NVMe SSDs នឹងមិនលឿនជាង SATA SSD របស់យើងដែលមានឃ្លាំងសម្ងាត់នោះទេ។ តាមពិតសម្រាប់ហេតុផលនេះ វាមិនសមហេតុផលសម្រាប់យើងក្នុងការធ្វើឱ្យភាគថាសឃ្លាំងសម្ងាត់ LVM ធំជាងទំហំឃ្លាំងសម្ងាត់ SLC នៃដ្រាយ NVMe ពីរដង។ សម្រាប់ដ្រាយ NVMe ដែលត្រូវបានប្រើ អ្នកនិពន្ធចាត់ទុកថាវាសមហេតុផលក្នុងការបង្កើតឃ្លាំងសម្ងាត់ 32-64 ជីហ្គាបៃ។

ទំហំភាគថាសដែលបានផ្តល់ឱ្យគឺត្រូវបានទាមទារដើម្បីរៀបចំ 64 ជីហ្គាបៃនៃឃ្លាំងសម្ងាត់ ទិន្នន័យមេតាឃ្លាំងសម្ងាត់ និងការបម្រុងទុកទិន្នន័យមេតា។

លើសពីនេះទៀតខ្ញុំកត់សម្គាល់ថាបន្ទាប់ពីការបិទប្រព័ន្ធកខ្វក់ LVM នឹងសម្គាល់ឃ្លាំងសម្ងាត់ទាំងមូលថាកខ្វក់ហើយនឹងធ្វើសមកាលកម្មម្តងទៀត។ លើសពីនេះទៅទៀត វានឹងត្រូវបានធ្វើម្តងទៀតរាល់ពេលដែល lvchange ត្រូវបានប្រើនៅលើឧបករណ៍នេះ រហូតដល់ប្រព័ន្ធត្រូវបានចាប់ផ្តើមឡើងវិញម្តងទៀត។ ដូច្នេះ ខ្ញុំ​សូម​ណែនាំ​ឱ្យ​បង្កើត​ឃ្លាំង​សម្ងាត់​ឡើង​វិញ​ភ្លាមៗ​ដោយ​ប្រើ​ស្គ្រីប​ដែល​សមរម្យ។

តោះបង្កើត LV នៅលើ SATA RAID 6 ដើម្បីប្រើវាជាឧបករណ៍ផ្ទុកក្នុងឃ្លាំងសម្ងាត់។

#lvcreate -L 3298543271936B --name cache data

ហេតុអ្វីបានត្រឹមតែបីតេរ៉ាបៃ..?ដូច្នេះប្រសិនបើចាំបាច់ អ្នកអាចប្រើ SATA SSD RAID 6 សម្រាប់តម្រូវការផ្សេងទៀត។ ទំហំនៃឃ្លាំងសម្ងាត់អាចត្រូវបានបង្កើនដោយថាមវន្ត ភ្លាមៗ ដោយមិនបញ្ឈប់ប្រព័ន្ធ។ ដើម្បីធ្វើដូច្នេះ អ្នកត្រូវបញ្ឈប់ជាបណ្តោះអាសន្ន និងបើកដំណើរការឃ្លាំងសម្ងាត់ឡើងវិញ ប៉ុន្តែអត្ថប្រយោជន៍ពិសេសនៃ LVM-cache លើសពីឧទាហរណ៍ bcache គឺថាវាអាចធ្វើបានភ្លាមៗ។

តោះបង្កើត VG ថ្មីសម្រាប់ឃ្លាំងសម្ងាត់។

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

តោះបង្កើត LV នៅលើឧបករណ៍ដែលបានរក្សាទុក។

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

នៅទីនេះភ្លាមៗយើងបានយកទំហំទំនេរទាំងអស់នៅលើ /dev/data/cache ដូច្នេះភាគថាសចាំបាច់ផ្សេងទៀតទាំងអស់ត្រូវបានបង្កើតភ្លាមៗនៅលើ /dev/root/cache ។ ប្រសិនបើអ្នកបានបង្កើតអ្វីមួយខុសកន្លែង អ្នកអាចផ្លាស់ទីវាដោយប្រើ pvmove។

តោះបង្កើត និងបើកឃ្លាំងសម្ងាត់៖

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

ហេតុអីក៏តូចម្ល៉េះ..?តាមរយៈការពិសោធន៍ជាក់ស្តែង អ្នកនិពន្ធអាចរកឃើញថា លទ្ធផលល្អបំផុតត្រូវបានសម្រេច ប្រសិនបើទំហំនៃប្លុកឃ្លាំងសម្ងាត់ LVM ស្របគ្នានឹងទំហំនៃប្លុកស្តើង LVM ។ លើសពីនេះទៅទៀត ទំហំតូចជាង ការកំណត់រចនាសម្ព័ន្ធដំណើរការកាន់តែប្រសើរឡើងក្នុងការថតដោយចៃដន្យ។

64k គឺជាទំហំប្លុកអប្បបរមាដែលអនុញ្ញាតសម្រាប់ LVM ស្តើង។

ប្រយ័ត្នស្តាយក្រោយ..!បាទ។ ប្រភេទនៃឃ្លាំងសម្ងាត់នេះពន្យាពេលសរសេរការធ្វើសមកាលកម្មទៅឧបករណ៍ដែលបានរក្សាទុក។ នេះមានន័យថាប្រសិនបើឃ្លាំងសម្ងាត់ត្រូវបានបាត់បង់ អ្នកអាចបាត់បង់ទិន្នន័យនៅលើឧបករណ៍ដែលលាក់ទុក។ ក្រោយមក អ្នកនិពន្ធនឹងប្រាប់អ្នកពីវិធានការអ្វីបន្ថែមពីលើ NVMe RAID 1 ដែលអាចត្រូវបានគេយកទៅទូទាត់សងសម្រាប់ហានិភ័យនេះ។

ប្រភេទឃ្លាំងសម្ងាត់នេះត្រូវបានជ្រើសរើសដោយចេតនាដើម្បីទូទាត់សងសម្រាប់ការសរសេរចៃដន្យមិនល្អនៃ RAID 6 ។

តោះពិនិត្យមើលអ្វីដែលយើងទទួលបាន៖

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

មានតែ [cachedata_corig] ប៉ុណ្ណោះដែលគួរតែមានទីតាំងនៅ /dev/data/cache ។ ប្រសិនបើមានអ្វីមួយខុស សូមប្រើ pvmove។

អ្នកអាចបិទឃ្លាំងសម្ងាត់ប្រសិនបើចាំបាច់ដោយប្រើពាក្យបញ្ជាមួយ៖

#lvconvert -y --uncache cache/cachedata

នេះត្រូវបានធ្វើនៅលើអ៊ីនធឺណិត។ LVM នឹងធ្វើសមកាលកម្មឃ្លាំងសម្ងាត់ទៅថាស លុបវាចេញ ហើយប្តូរឈ្មោះ cachedata_corig ត្រឡប់ទៅឃ្លាំងសម្ងាត់វិញ។

ការដំឡើង LVM ស្តើង

ចូរប៉ាន់ប្រមាណថាតើយើងត្រូវការទំហំប៉ុនណាសម្រាប់ទិន្នន័យមេតាស្តើង LVM៖

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

បង្គត់រហូតដល់ 4 ជីហ្គាបៃ: 4294967296B

គុណនឹងពីរ ហើយបន្ថែម 4194304B សម្រាប់ទិន្នន័យមេតា LVM PV: 8594128896B
តោះបង្កើតភាគថាសដាច់ដោយឡែកនៅលើ NVMe RAID 1 ដើម្បីដាក់ទិន្នន័យមេតាស្តើង LVM និងច្បាប់ចម្លងបម្រុងទុករបស់ពួកគេនៅលើវា៖

#lvcreate -L 8594128896B --name images root

ដើម្បីអ្វី..?នៅទីនេះសំណួរអាចកើតឡើង: ហេតុអ្វីបានជាដាក់ទិន្នន័យមេតាស្តើង LVM ដោយឡែកពីគ្នាប្រសិនបើវានឹងនៅតែត្រូវបានរក្សាទុកនៅលើ NVMe ហើយនឹងដំណើរការយ៉ាងឆាប់រហ័ស។

ទោះបីជាល្បឿនមានសារៈសំខាន់នៅទីនេះក៏ដោយ វាគឺនៅឆ្ងាយពីហេតុផលចម្បង។ រឿងគឺថាឃ្លាំងសម្ងាត់គឺជាចំណុចនៃការបរាជ័យ។ អ្វីមួយអាចកើតឡើងចំពោះវា ហើយប្រសិនបើទិន្នន័យមេតាស្តើង LVM ត្រូវបានទុកក្នុងឃ្លាំងសម្ងាត់ វានឹងធ្វើឱ្យអ្វីៗទាំងអស់ត្រូវបាត់បង់ទាំងស្រុង។ បើគ្មានទិន្នន័យមេតាពេញលេញទេ វានឹងស្ទើរតែមិនអាចទៅរួចទេក្នុងការប្រមូលផ្តុំបរិមាណស្តើង។

តាមរយៈការផ្លាស់ប្តូរទិន្នន័យមេតាទៅជាផ្នែកដាច់ដោយឡែកដែលមិនមានឃ្លាំងសម្ងាត់ ប៉ុន្តែមានកម្រិតសំឡេងលឿន យើងធានាសុវត្ថិភាពនៃទិន្នន័យមេតាក្នុងករណីបាត់បង់ឃ្លាំងសម្ងាត់ ឬអំពើពុករលួយ។ ក្នុងករណីនេះ ការខូចខាតទាំងអស់ដែលបណ្តាលមកពីការបាត់បង់ឃ្លាំងសម្ងាត់នឹងត្រូវបានធ្វើមូលដ្ឋានីយកម្មនៅក្នុងបរិមាណស្តើង ដែលនឹងធ្វើឱ្យនីតិវិធីនៃការស្តារឡើងវិញមានភាពសាមញ្ញតាមលំដាប់លំដោយ។ ជាមួយនឹងប្រូបាប៊ីលីតេខ្ពស់ ការខូចខាតទាំងនេះនឹងត្រូវបានស្ដារឡើងវិញដោយប្រើកំណត់ហេតុ FS ។

លើសពីនេះទៅទៀត ប្រសិនបើរូបថតនៃកម្រិតសំឡេងស្តើងមួយត្រូវបានថតពីមុន ហើយបន្ទាប់ពីនោះឃ្លាំងសម្ងាត់ត្រូវបានធ្វើសមកាលកម្មយ៉ាងពេញលេញយ៉ាងហោចណាស់ម្តង នោះដោយសារតែការរចនាខាងក្នុងនៃ LVM ស្តើង ភាពសុចរិតនៃរូបថតនឹងត្រូវបានធានាក្នុងករណីបាត់បង់ឃ្លាំងសម្ងាត់។ .

តោះបង្កើត VG ថ្មីដែលនឹងទទួលខុសត្រូវលើការផ្តល់ស្តើង៖

#pvcreate /dev/root/images
#pvcreate /dev/cache/cachedata
#vgcreate images /dev/root/images /dev/cache/cachedata
តោះបង្កើតអាងទឹក៖

#lvcreate -L 274877906944B --poolmetadataspare y --poolmetadatasize 4294967296B --chunksize 64k -Z y -T images/thin-pool
ហេតុអ្វី -Z yបន្ថែមពីលើអ្វីដែលរបៀបនេះគឺពិតជាមានបំណងសម្រាប់ - ដើម្បីការពារទិន្នន័យពីម៉ាស៊ីននិម្មិតមួយពីការលេចធ្លាយទៅម៉ាស៊ីននិម្មិតមួយផ្សេងទៀតនៅពេលចែកចាយចន្លោះឡើងវិញ - សូន្យត្រូវបានប្រើបន្ថែមដើម្បីបង្កើនល្បឿននៃការសរសេរចៃដន្យនៅក្នុងប្លុកតូចជាង 64k ។ រាល់ការសរសេរតិចជាង 64k ទៅតំបន់ដែលមិនបានបែងចែកពីមុននៃបរិមាណស្តើងនឹងក្លាយទៅជា 64K edge-aligned នៅក្នុងឃ្លាំងសម្ងាត់។ វា​នឹង​អនុញ្ញាត​ឱ្យ​ប្រតិបត្តិ​ការ​ទាំង​ស្រុង​តាម​រយៈ​ឃ្លាំង​សម្ងាត់ ដោយ​រំលង​ឧបករណ៍​ក្នុង​ឃ្លាំង​សម្ងាត់។

តោះផ្លាស់ទី LVs ទៅ PVs ដែលត្រូវគ្នា៖

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

តោះពិនិត្យ៖

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

តោះបង្កើតកម្រិតសំឡេងស្តើងសម្រាប់ការធ្វើតេស្ត៖

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

យើងនឹងដំឡើងកញ្ចប់សម្រាប់ការធ្វើតេស្ត និងការត្រួតពិនិត្យ៖

#apt-get install sysstat fio

នេះជារបៀបដែលអ្នកអាចសង្កេតមើលឥរិយាបថនៃការកំណត់រចនាសម្ព័ន្ធផ្ទុករបស់យើងក្នុងពេលវេលាជាក់ស្តែង៖

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

នេះជារបៀបដែលយើងអាចសាកល្បងការកំណត់រចនាសម្ព័ន្ធរបស់យើង៖

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

ប្រយ័ត្ន! ធនធាន!លេខកូដនេះនឹងដំណើរការការធ្វើតេស្តចំនួន 36 ផ្សេងៗគ្នា ដែលនីមួយៗដំណើរការរយៈពេល 4 វិនាទី។ ពាក់កណ្តាលនៃការធ្វើតេស្តគឺសម្រាប់ការថត។ អ្នកអាចថតបានច្រើននៅលើ NVMe ក្នុងរយៈពេល 4 វិនាទី។ រហូតដល់ 3 ជីហ្គាបៃក្នុងមួយវិនាទី។ ដូច្នេះ រាល់ការធ្វើតេស្តសរសេរអាចស៊ីធនធាន SSD ដល់ទៅ 216 ជីហ្គាបៃពីអ្នក។

ការអាន និងការសរសេរលាយឡំគ្នា?បាទ។ វាសមហេតុផលក្នុងការដំណើរការតេស្តអាន និងសរសេរដោយឡែកពីគ្នា។ លើសពីនេះទៅទៀត វាសមហេតុផលក្នុងការធានាថាឃ្លាំងសម្ងាត់ទាំងអស់ត្រូវបានធ្វើសមកាលកម្ម ដូច្នេះការសរសេរដែលបានធ្វើពីមុនមិនប៉ះពាល់ដល់ការអាននោះទេ។

លទ្ធផលនឹងប្រែប្រួលយ៉ាងខ្លាំងក្នុងអំឡុងពេលបើកដំណើរការដំបូង និងជាបន្តបន្ទាប់ នៅពេលដែលឃ្លាំងសម្ងាត់ និងបរិមាណស្តើងបំពេញឡើង ហើយក៏អាស្រ័យទៅលើថាតើប្រព័ន្ធគ្រប់គ្រងដើម្បីធ្វើសមកាលកម្មឃ្លាំងសម្ងាត់ដែលបានបំពេញក្នុងអំឡុងពេលនៃការបើកដំណើរការចុងក្រោយ។

ក្នុងចំណោមរបស់ផ្សេងទៀត ខ្ញុំសូមណែនាំឱ្យវាស់ល្បឿននៅលើកម្រិតសំឡេងស្តើងពេញលេញដែលរូបថតទើបតែថត។ អ្នកនិពន្ធមានឱកាសដើម្បីសង្កេតមើលពីរបៀបដែលការសរសេរចៃដន្យបង្កើនល្បឿនភ្លាមៗបន្ទាប់ពីបង្កើតរូបថតដំបូង ជាពិសេសនៅពេលដែលឃ្លាំងសម្ងាត់មិនទាន់ពេញ។ វាកើតឡើងដោយសារការចម្លងលើការសរសេរសមីការ ការតម្រឹមឃ្លាំងសម្ងាត់ និងប្លុកកម្រិតសំឡេងស្តើង ហើយការពិតដែលថាការសរសេរចៃដន្យទៅ RAID 6 ប្រែទៅជាការអានចៃដន្យពី RAID 6 អមដោយការសរសេរទៅឃ្លាំងសម្ងាត់។ នៅក្នុងការកំណត់រចនាសម្ព័ន្ធរបស់យើង ការអានចៃដន្យពី RAID 6 គឺរហូតដល់ 6 ដង (ចំនួន SATA SSDs នៅក្នុងអារេ) លឿនជាងការសរសេរ។ ដោយសារតែ ប្លុកសម្រាប់ CoW ត្រូវបានបែងចែកតាមលំដាប់លំដោយពីអាងស្តើង បន្ទាប់មកការថតសំឡេងក៏ប្រែទៅជាបន្តបន្ទាប់គ្នាផងដែរ។

មុខងារទាំងពីរនេះអាចត្រូវបានប្រើដើម្បីផលប្រយោជន៍របស់អ្នក។

ឃ្លាំងសម្ងាត់រូបថត "ជាប់គ្នា"

ដើម្បីកាត់បន្ថយហានិភ័យនៃការបាត់បង់ទិន្នន័យក្នុងករណីមានការខូចខាត/បាត់បង់ឃ្លាំងសម្ងាត់ អ្នកនិពន្ធស្នើឱ្យណែនាំការអនុវត្តការបង្វិលរូបថតដើម្បីធានាភាពត្រឹមត្រូវរបស់ពួកគេក្នុងករណីនេះ។

ទីមួយ ដោយសារទិន្នន័យមេតាបរិមាណស្តើងស្ថិតនៅលើឧបករណ៍ដែលមិនបានរក្សាទុក ទិន្នន័យមេតានឹងមានភាពស៊ីសង្វាក់គ្នា ហើយការខាតបង់ដែលអាចកើតមាននឹងត្រូវញែកដាច់ពីគេក្នុងប្លុកទិន្នន័យ។

វដ្តបង្វិលរូបថតខាងក្រោមធានានូវភាពត្រឹមត្រូវនៃទិន្នន័យនៅខាងក្នុងរូបថត ក្នុងករណីបាត់បង់ឃ្លាំងសម្ងាត់៖

1. សម្រាប់ភាគស្តើងនីមួយៗដែលមានឈ្មោះ <name> បង្កើតរូបថតមួយសន្លឹកដែលមានឈ្មោះ <name>.cached
2. ចូរកំណត់កម្រិតនៃការធ្វើចំណាកស្រុកទៅជាតម្លៃខ្ពស់សមរម្យ៖ #lvchange --quiet --cachesettings "migration_threshold=16384" cache/cachedata
3. នៅក្នុងរង្វិលជុំយើងពិនិត្យមើលចំនួនប្លុកកខ្វក់នៅក្នុងឃ្លាំងសម្ងាត់: #lvs --rows --reportformat basic --quiet -ocache_dirty_blocks cache/cachedata | awk '{print $2}' រហូតដល់យើងទទួលបានសូន្យ។ ប្រសិនបើសូន្យបាត់យូរពេក វាអាចត្រូវបានបង្កើតដោយការប្តូរឃ្លាំងសម្ងាត់ជាបណ្តោះអាសន្នទៅជារបៀបសរសេរតាមរយៈ។ ទោះជាយ៉ាងណាក៏ដោយ ដោយគិតគូរពីលក្ខណៈល្បឿននៃអារេ SATA និង NVMe SSD របស់យើង ក៏ដូចជាធនធាន TBW របស់ពួកគេ អ្នកនឹងអាចចាប់បានភ្លាមៗដោយមិនផ្លាស់ប្តូររបៀបឃ្លាំងសម្ងាត់ ឬផ្នែករឹងរបស់អ្នកនឹងស៊ីធនធានទាំងមូលរបស់វាទាំងស្រុងនៅក្នុង ពីរបី​ថ្ងៃ។ ដោយសារតែដែនកំណត់ធនធាន ប្រព័ន្ធជាគោលការណ៍មិនអាចស្ថិតនៅក្រោម 100% នៃការសរសេរគ្រប់ពេលវេលា។ NVMe SSDs របស់យើងក្រោមការផ្ទុកការសរសេរ 100% នឹងអស់ធនធានទាំងស្រុង 3-4 ថ្ងៃ។. SATA SSDs នឹងមានរយៈពេលយូរជាងពីរដងប៉ុណ្ណោះ។ ដូច្នេះហើយ យើងនឹងសន្មត់ថា ភាគច្រើននៃបន្ទុកគឺទៅការអាន ហើយយើងមានការផ្ទុះរយៈពេលខ្លីនៃសកម្មភាពខ្ពស់ខ្លាំង រួមជាមួយនឹងបន្ទុកទាបជាមធ្យមសម្រាប់ការសរសេរ។
4. ដរាបណាយើងចាប់បាន (ឬបង្កើត) សូន្យ យើងប្តូរឈ្មោះ <name>.cached ទៅ <name>.committed។ <name>.committed ចាស់​ត្រូវ​បាន​លុប។
5. ជាជម្រើស ប្រសិនបើឃ្លាំងសម្ងាត់ពេញ 100% វាអាចត្រូវបានបង្កើតឡើងវិញដោយស្គ្រីប ដូច្នេះសម្អាតវា។ ជាមួយនឹងឃ្លាំងសម្ងាត់ពាក់កណ្តាលទទេ ប្រព័ន្ធដំណើរការលឿនជាងមុននៅពេលសរសេរ។
6. កំណត់កម្រិតនៃការធ្វើចំណាកស្រុកទៅសូន្យ៖ #lvchange --quiet --cachesettings "migration_threshold=0" cache/cachedata វា​នឹង​រារាំង​ឃ្លាំង​សម្ងាត់​ជា​បណ្ដោះអាសន្ន​ពី​ការ​ធ្វើ​សមកាលកម្ម​ទៅ​មេឌៀ​ចម្បង។
7. យើងរង់ចាំរហូតដល់ការផ្លាស់ប្តូរជាច្រើនកកកុញនៅក្នុងឃ្លាំងសម្ងាត់ #lvs --rows --reportformat basic --quiet -ocache_dirty_blocks cache/cachedata | awk '{print $2}' ឬកម្មវិធីកំណត់ម៉ោងនឹងរលត់។
8. យើងធ្វើម្តងទៀត។

ហេតុអ្វី​បាន​ជា​ពិបាក​នឹង​កម្រិត​នៃ​ការ​ធ្វើ​ចំណាកស្រុក...?រឿងនេះគឺថានៅក្នុងការអនុវត្តជាក់ស្តែងការថត "ចៃដន្យ" គឺពិតជាមិនចៃដន្យទាំងស្រុង។ ប្រសិនបើយើងសរសេរអ្វីមួយទៅផ្នែកដែលមានទំហំ 4 គីឡូបៃ វាមានប្រូបាប៊ីលីតេខ្ពស់ដែលក្នុងរយៈពេលពីរបីនាទីបន្ទាប់ កំណត់ត្រាមួយនឹងត្រូវបានធ្វើឡើងចំពោះផ្នែកដូចគ្នា ឬផ្នែកមួយរបស់អ្នកជិតខាង (+- 32K) ។

តាមរយៈការកំណត់កម្រិតនៃការធ្វើចំណាកស្រុកទៅសូន្យ យើងពន្យារពេលសរសេរការធ្វើសមកាលកម្មនៅលើ SATA SSD ហើយប្រមូលផ្តុំការផ្លាស់ប្តូរមួយចំនួនទៅជាប្លុក 64K មួយនៅក្នុងឃ្លាំងសម្ងាត់។ នេះរក្សាទុកយ៉ាងសំខាន់នូវធនធានរបស់ SATA SSD ។

លេខកូដនៅឯណា..ជាអកុសល អ្នកនិពន្ធចាត់ទុកថាខ្លួនគាត់មិនមានជំនាញគ្រប់គ្រាន់ក្នុងការអភិវឌ្ឍន៍ស្គ្រីប bash ទេ ដោយសារគាត់បង្រៀនខ្លួនឯង 100% និងអនុវត្តការអភិវឌ្ឍន៍ដែលជំរុញដោយ "google" ដូច្នេះគាត់ជឿថាលេខកូដដ៏អាក្រក់ដែលចេញពីដៃរបស់គាត់មិនគួរត្រូវបានប្រើប្រាស់ដោយនរណាម្នាក់ឡើយ។ ផ្សេងទៀត។

ខ្ញុំគិតថាអ្នកជំនាញក្នុងវិស័យនេះនឹងអាចពណ៌នាដោយឯករាជ្យនូវតក្កវិជ្ជាទាំងអស់ដែលបានពិពណ៌នាខាងលើ ប្រសិនបើចាំបាច់ ហើយប្រហែលជាសូម្បីតែរចនាវាយ៉ាងស្រស់ស្អាតជាសេវាកម្មប្រព័ន្ធ ដូចដែលអ្នកនិពន្ធបានព្យាយាមធ្វើ។

គ្រោងការណ៍បង្វិលរូបថតសាមញ្ញបែបនេះនឹងអនុញ្ញាតឱ្យយើងមិនត្រឹមតែមានរូបថតមួយសន្លឹកដែលធ្វើសមកាលកម្មយ៉ាងពេញលេញនៅលើ SATA SSD ប៉ុណ្ណោះទេ ប៉ុន្តែក៏នឹងអនុញ្ញាតឱ្យយើងដោយប្រើឧបករណ៍ប្រើប្រាស់ thin_delta ដើម្បីរកមើលថាតើប្លុកណាមួយត្រូវបានផ្លាស់ប្តូរបន្ទាប់ពីការបង្កើតរបស់វា ហើយដូច្នេះធ្វើមូលដ្ឋានីយកម្មការខូចខាតនៅលើ បរិមាណសំខាន់ៗ ធ្វើឱ្យការស្តារឡើងវិញកាន់តែងាយស្រួល។

TRIM/DISCARD ក្នុង libvirt/KVM

ដោយសារតែ ការផ្ទុកទិន្នន័យនឹងត្រូវបានប្រើសម្រាប់ KVM ដែលដំណើរការ libvirt បន្ទាប់មកវាជាការល្អក្នុងការបង្រៀន VMs របស់យើងមិនត្រឹមតែយកទំហំទំនេរប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងបង្កើននូវអ្វីដែលលែងត្រូវការទៀតផង។

នេះត្រូវបានធ្វើដោយត្រាប់តាមការគាំទ្រ 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>

ការបោះបង់ចោលបែបនេះពី OSes ភ្ញៀវត្រូវបានដំណើរការយ៉ាងត្រឹមត្រូវដោយ LVM ហើយប្លុកត្រូវបានដោះលែងយ៉ាងត្រឹមត្រូវទាំងនៅក្នុងឃ្លាំងសម្ងាត់ និងនៅក្នុងអាងស្តើង។ ក្នុងករណីរបស់យើង វាកើតឡើងជាចម្បងក្នុងលក្ខណៈពន្យារពេល នៅពេលលុបរូបថតបន្ទាប់។

ការបម្រុងទុក BTRFS

ប្រើស្គ្រីបដែលត្រៀមរួចជាស្រេចជាមួយ ខ្លាំង ការប្រុងប្រយ័ត្ននិង នៅក្នុងហានិភ័យផ្ទាល់ខ្លួន. អ្នកនិពន្ធសរសេរកូដនេះដោយខ្លួនឯង និងសម្រាប់ខ្លួនគាត់ផ្ទាល់។ ខ្ញុំប្រាកដថាអ្នកប្រើប្រាស់លីនុចដែលមានបទពិសោធន៍ជាច្រើនមានឧបករណ៍ស្រដៀងគ្នា ហើយមិនចាំបាច់ចម្លងអ្នកផ្សេងទេ។

តោះបង្កើតកម្រិតសំឡេងនៅលើឧបករណ៍បម្រុងទុក៖

#lvcreate -L 256G --name backup backup

តោះធ្វើទ្រង់ទ្រាយវាក្នុង BTRFS៖

#mkfs.btrfs /dev/backup/backup

តោះបង្កើតចំណុចម៉ោន និងម៉ោនផ្នែករងរបស់ប្រព័ន្ធឯកសារ៖

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

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

តោះបង្កើតថតឯកសារសម្រាប់ការបម្រុងទុក៖

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

តោះបង្កើតថតសម្រាប់ស្គ្រីបបម្រុងទុក៖

#mkdir /root/btrfs-backup

តោះចម្លងស្គ្រីប៖

កូដ bash គួរឱ្យខ្លាចជាច្រើន។ ប្រើដោយហានិភ័យផ្ទាល់ខ្លួនរបស់អ្នក។ កុំ​សរសេរ​សំបុត្រ​ខឹង​អ្នក​និពន្ធ...#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 និងចម្លងពួកវាទៅ FS ផ្សេងទៀតដោយប្រើ BTRFS ផ្ញើ / ទទួល។

ការ​បាញ់​បង្ហោះ​លើក​ដំបូង​អាច​មាន​រយៈ​ពេល​យូរ​ព្រោះ... នៅពេលចាប់ផ្តើម ទិន្នន័យទាំងអស់នឹងត្រូវបានចម្លង។ ការ​បាញ់​បង្ហោះ​បន្ថែម​ទៀត​នឹង​មាន​ល្បឿន​លឿន​ណាស់​ព្រោះ​... មានតែការផ្លាស់ប្តូរប៉ុណ្ណោះដែលនឹងត្រូវបានចម្លង។

ស្គ្រីបមួយទៀតដែលយើងនឹងដាក់ចូលទៅក្នុង cron៖

កូដ bash មួយចំនួនទៀត។#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


តើ​វា​ធ្វើអ្វី..?បង្កើត និងធ្វើសមកាលកម្មរូបថតបន្ថែមនៃបរិមាណ BTRFS ដែលបានរាយបញ្ជីនៅលើ FS បម្រុងទុក។ បន្ទាប់ពីនេះ វាលុបរូបភាពទាំងអស់ដែលបានបង្កើតកាលពី 60 ថ្ងៃមុន។ បន្ទាប់ពីបើកដំណើរការ រូបថតដែលបានចុះកាលបរិច្ឆេទនៃភាគដែលបានរាយបញ្ជីនឹងបង្ហាញនៅក្នុងថតរង /backup/btrfs/back/remote/ ។

តោះផ្តល់សិទ្ធិប្រតិបត្តិកូដ៖

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

តោះពិនិត្យមើលវាហើយដាក់វានៅក្នុង cron:

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


ការបម្រុងទុក LVM ស្តើង

តោះបង្កើតអាងស្តើងមួយនៅលើឧបករណ៍បម្រុងទុក៖

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

តោះដំឡើង ddrescue ព្រោះ... ស្គ្រីបនឹងប្រើឧបករណ៍នេះ៖

#apt-get install gddrescue

តោះបង្កើតថតសម្រាប់ស្គ្រីប៖

#mkdir /root/lvm-thin-backup

តោះចម្លងស្គ្រីប៖

បែកញើសច្រើននៅខាងក្នុង...#cat >/root/lvm-thin-backup/lvm-thin-backup.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

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

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

export LVM_SUPPRESS_FD_WARNINGS=1

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

function wait_lock()
{
flock 98
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

dmsetup message $DIFF_POOL_PATH_TPOOL 0 release_metadata_snap

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

}

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

activate_volume $SYNC_VG $SYNC_PEND

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

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

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

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

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

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

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

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

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

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

echo Syncronizing "$SOURCE_BASE_LV_PATH" to "$TARGET_BASE_LV_PATH"

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

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

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

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

}

(
COMMAND="$1"
shift

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

EOF


តើ​វា​ធ្វើអ្វី...?មានសំណុំនៃពាក្យបញ្ជាសម្រាប់រៀបចំរូបថតស្តើង និងធ្វើសមកាលកម្មភាពខុសគ្នារវាងរូបថតស្តើងពីរដែលទទួលបានតាមរយៈ thin_delta ទៅឧបករណ៍ប្លុកផ្សេងទៀតដោយប្រើ ddrescue និង blkdiscard ។

ស្គ្រីបមួយទៀតដែលយើងនឹងដាក់ក្នុង cron៖

បុកបន្តិចទៀត។#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

តោះពិនិត្យមើលវាហើយដាក់វានៅក្នុង cron:

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

ការ​សម្ពោធ​លើក​ដំបូង​នឹង​មាន​រយៈពេល​យូរ​ព្រោះ... បរិមាណស្តើងនឹងត្រូវបានធ្វើសមកាលកម្មពេញលេញដោយចម្លងទំហំដែលបានប្រើទាំងអស់។ សូមអរគុណចំពោះទិន្នន័យមេតាស្តើងរបស់ LVM យើងដឹងថាប្លុកណាមួយកំពុងប្រើប្រាស់យ៉ាងពិតប្រាកដ ដូច្នេះមានតែប្លុកបរិមាណស្តើងដែលបានប្រើពិតប្រាកដប៉ុណ្ណោះនឹងត្រូវបានចម្លង។

ការរត់ជាបន្តបន្ទាប់នឹងចម្លងទិន្នន័យជាបន្តបន្ទាប់ ដោយសារការផ្លាស់ប្តូរការតាមដានតាមរយៈទិន្នន័យមេតាស្តើង LVM ។

តោះមើលថាមានអ្វីកើតឡើង៖

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

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

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

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


តើ​នេះ​មាន​អ្វី​ទាក់ទង​នឹង​តុក្កតា​សំបុក?

ភាគច្រើនទំនងជាត្រូវបានផ្តល់ឱ្យថាបរិមាណឡូជីខល LVM LV អាចជាបរិមាណរូបវន្ត LVM PV សម្រាប់ VGs ផ្សេងទៀត។ LVM អាចកើតឡើងដដែលៗ ដូចជាតុក្កតាសំបុក។ នេះផ្តល់ឱ្យ LVM មានភាពបត់បែនខ្លាំង។

PS

នៅក្នុងអត្ថបទបន្ទាប់ យើងនឹងព្យាយាមប្រើប្រព័ន្ធផ្ទុកទិន្នន័យចល័តស្រដៀងគ្នាមួយចំនួន/KVM ជាមូលដ្ឋានសម្រាប់បង្កើតចង្កោមកន្លែងផ្ទុក/vm ដែលបានចែកចាយតាមភូមិសាស្រ្តជាមួយនឹងការលែងត្រូវការតទៅទៀតនៅលើទ្វីបជាច្រើនដោយប្រើកុំព្យូទ័រលើតុផ្ទះ អ៊ីនធឺណិតនៅផ្ទះ និងបណ្តាញ P2P ។

ប្រភព: www.habr.com