💂🏼 🥑 🤘🏾 LVM और matryoshka के बीच क्या आम है? 🛎️ 🌅 👨🏼‍🚒

अच्छा दिन।
मैं md RAID + LVM का उपयोग करके KVM के लिए संग्रहण प्रणाली बनाने में सामुदायिक व्यावहारिक अनुभव के साथ साझा करना चाहता हूं।

कार्यक्रम होगा:

NVMe SSD से md RAID 1 बनाएँ।
SATA SSD और नियमित ड्राइव से md RAID 6 बनाएँ।
SSD RAID 1/6 पर TRIM / DISCARD की विशेषताएं।
डिस्क के एक सामान्य सेट पर बूट करने योग्य md RAID 1/6 सरणी।
यदि BIOS में कोई NVMe समर्थन नहीं है, तो NVMe RAID 1 पर सिस्टम इंस्टॉल करना।
LVM कैश और LVM पतली का उपयोग करना।
BTRFS स्नैपशॉट का उपयोग करना और बैकअप के लिए भेजना / प्राप्त करना।
BTRFS शैली बैकअप के लिए LVM पतले स्नैपशॉट और thin_delta का उपयोग करना।

अगर दिलचस्पी है, तो कृपया, बिल्ली के नीचे।

बयान

लेखक इस लेख से सामग्री / उदाहरण / कोड / टिप्स / डेटा का उपयोग करने या न करने के परिणामों के लिए कोई ज़िम्मेदारी नहीं उठाता है। इस सामग्री को किसी भी तरह से पढ़ने या उपयोग करने से, आप इन कार्यों के सभी परिणामों की जिम्मेदारी लेते हैं। संभावित परिणामों में शामिल हैं:

क्रिस्पी फ्राइड NVMe SSD।
पूरी तरह से उपयोग किए गए रिकॉर्डिंग संसाधन और एसएसडी ड्राइव की विफलता।
बैकअप सहित सभी ड्राइव पर सभी डेटा का पूर्ण नुकसान।
दोषपूर्ण कंप्यूटर हार्डवेयर।
समय, नसों और पैसे खर्च किए।
कोई अन्य प्रभाव ऊपर सूचीबद्ध नहीं है।

लोहा

स्टॉक में था:

मदरबोर्ड Z87 चिपसेट पर इंटेल कोर i7 / हैसवेल के साथ 2013 के आसपास है।

सीपीयू 4 कोर, 8 धागे
DDR3 रैम के 32 गीगाबाइट
1 x 16 या 2 x 8 PCIe 3.0
1 x 4 + 1 x 1 PCIe 2.0
6 x 6 जीबीपीएस एसएटीए 3 कनेक्टर

SAS एडाप्टर LSI SAS9211-8I IT / HBA मोड में चला गया। RAID- सक्षम फर्मवेयर को जानबूझकर HBA फर्मवेयर के साथ बदल दिया गया है:

किसी भी समय इस एडॉप्टर को फेंकना संभव था और इसे पहले किसी अन्य के साथ बदल दिया गया था।
TRIM / डिस्कर्ड ने सामान्य रूप से डिस्क पर काम किया, जैसा कि RAID फर्मवेयर में, ये कमांड बिल्कुल भी समर्थित नहीं हैं, और HBA, सामान्य रूप से, परवाह नहीं करता है कि बस में क्या कमांड भेजनी है।

हार्ड ड्राइव - लैपटॉप के लिए फॉर्म फैक्टर 2.5 में 1 टीबी की मात्रा के साथ एचजीएसटी ट्रैवलस्टार 7 के 1000 के 8 टुकड़े। ये ड्राइव पहले एक RAID 6 सरणी में थे। नई प्रणाली में, वे भी आवेदन पाएंगे। स्थानीय बैकअप संग्रहीत करने के लिए।

इसके अतिरिक्त यह जोड़ा गया था:

SATA SSD मॉडल सैमसंग 660 QVO 2TB के 6 टुकड़े। इन SSD को एक बड़ी राशि, एक SLC कैश की उपस्थिति, विश्वसनीयता वांछनीय और कम कीमत की आवश्यकता होती है। अनिवार्य को त्याग / शून्य के लिए समर्थन था जिसे dmesg में एक लाइन द्वारा जांचा गया है:

kernel: ata1.00: Enabling discard_zeroes_data

NVMe SSD मॉडल सैमसंग SSD 970 EVO 500GB के 2 टुकड़े।

इन SSDs के लिए, यादृच्छिक पढ़ने / लिखने की गति और आपकी आवश्यकताओं के लिए एक संसाधन महत्वपूर्ण हैं। उन्हें रेडिएटर। अनिवार्य। बिलकुल जरूरी। अन्यथा, उन्हें पहले रवा तुल्यकालन के दौरान कुरकुरा होने तक भूनें।

PCIT 3.0 8x स्लॉट के साथ 2 x NVMe SSDs के लिए स्टारटेक PEX8M2E2 एडॉप्टर। यह, फिर से, सिर्फ एचबीए है, लेकिन एनवीएमई के लिए। यह एक एकीकृत PCIe स्विच की उपस्थिति के कारण मदरबोर्ड से PCIe द्विभाजन समर्थन की आवश्यकता के अभाव में सस्ते एडेप्टर से अलग है। यह सबसे पुरानी प्रणाली में भी काम करेगा जहां PCIe है, भले ही यह X1 PCIe 1.0 स्लॉट हो। स्वाभाविक रूप से, उचित गति के साथ। वहाँ कोई RAID हैं। बोर्ड पर कोई एकीकृत BIOS नहीं है। तो, आपका सिस्टम NVMe से बूट करना नहीं सीखेगा, इस डिवाइस के लिए NVMe RAID धन्यवाद बहुत कम है।

यह घटक पूरी तरह से सिस्टम में केवल एक मुफ्त 8x PCIe 3.0 की उपस्थिति के कारण होता था, और 2 मुफ्त स्लॉट की उपस्थिति में, इसे आसानी से दो सस्ते PEX4M2E1 या एनालॉग्स द्वारा प्रतिस्थापित किया जाता है, जिसे 600 रूबल की कीमत पर कहीं भी खरीदा जा सकता है।

एसएसडी / एचडीडी के अपवाद के साथ, पूरे डेटा को पूरी तरह से बदलने में सक्षम होने के लिए सभी प्रकार के हार्डवेयर या एकीकृत RAID चिपसेट / BIOS के अस्वीकृति को जानबूझकर बनाया गया था, जिससे सभी डेटा की बचत होती है। आदर्श रूप से, पूरी तरह से नए / अलग हार्डवेयर में जाने पर भी स्थापित ऑपरेटिंग सिस्टम को रखना संभव होगा। मुख्य बात यह है कि SATA और PCIe पोर्ट हैं। यह एक लाइव सीडी या बूट करने योग्य फ्लैश ड्राइव की तरह है, केवल बहुत तेज़ और थोड़ा ओवरसाइज़्ड है।

हास्य

, , — . . 5.25 .

ठीक है, और निश्चित रूप से, लिनक्स में एसएसडी कैशिंग के विभिन्न तरीकों के साथ प्रयोग करने के लिए।

हार्डवेयर छापे, यह उबाऊ है। चालू करो। यह काम करता है या नहीं। और mdadm के साथ हमेशा विकल्प होते हैं।

मुलायम

पहले, डेबियन 8 जेसी हार्डवेयर पर स्थापित किया गया था, जो ईओएल के करीब है। ऊपर उल्लिखित HDD से RAID 6 को LVM के साथ जोड़ा गया था। यह kvm / libvirt में वर्चुअल मशीन चला रहा था।

चूंकि लेखक को पोर्टेबल बूट करने योग्य SATA / NVMe फ्लैश ड्राइव बनाने में उपयुक्त अनुभव है, और इसके अलावा, सामान्य एप-टेम्पलेट को फाड़ने के लिए नहीं, उबंटू 18.04 को लक्ष्य प्रणाली के रूप में चुना गया था, जो पहले से ही पर्याप्त रूप से स्थिर हो गया है, लेकिन अभी भी भविष्य में 3 साल का समर्थन है।

उल्लिखित प्रणाली में सभी हार्डवेयर ड्राइवर हैं जिनकी हमें आवश्यकता है बॉक्स से बाहर। हमें किसी भी तृतीय-पक्ष सॉफ़्टवेयर और ड्राइवरों की आवश्यकता नहीं है।

स्थापना की तैयारी

सिस्टम को स्थापित करने के लिए, हमें उबंटू डेस्कटॉप इमेज की आवश्यकता है। सर्वर सिस्टम में कुछ प्रकार के जोरदार इंस्टॉलर हैं जो अत्यधिक, गैर-डिस्कनेक्ट करने योग्य स्वतंत्रता का प्रदर्शन करते हैं, हमेशा यूईएफआई सिस्टम विभाजन को धक्का देते हैं जो सभी सौंदर्य को खराब कर रहे डिस्क में से एक पर होता है। तदनुसार, यह केवल यूईएफआई मोड में स्थापित है। यह विकल्प प्रदान नहीं करता है।

यह हमें शोभा नहीं देता।

क्यों?

, UEFI RAID, .. UEFI ESP . , ESP USB , , . mdadm RAID 1 0.9 UEFI BIOS , , BIOS - ESP .

, UEFI NVRAM, , .. .

, . , Legacy/BIOS boot, CSM UEFI- . , , .

उबंटू के डेस्कटॉप संस्करण को यह भी पता नहीं है कि लिगेसी बूटलोडर के साथ सामान्य रूप से कैसे स्थापित किया जाए, लेकिन यहां, जैसा कि वे कहते हैं, कम से कम विकल्प हैं।

और इसलिए, हार्डवेयर को इकट्ठा करें और बूट करने योग्य उबंटू लाइव फ्लैश ड्राइव से सिस्टम को लोड करें। हमें पैकेज डाउनलोड करने की आवश्यकता होगी, इसलिए हमने नेटवर्क स्थापित किया, जिसने आपको अर्जित किया। यदि यह काम नहीं करता है, तो आप अग्रिम में आवश्यक पैकेज को USB फ्लैश ड्राइव पर डाउनलोड कर सकते हैं।

हम डेस्कटॉप वातावरण में जाते हैं, टर्मिनल एमुलेटर चलाते हैं, और चलते हैं:

#sudo bash

किस तरह...?

sudo. . , . sudo , . :

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

ZFS क्यों नहीं ...?

, — , .
, — , - .

ZFS — , mdadm+lvm .

. . . . . . , .

फिर BTRFS क्यों ...?

Legacy/BIOS GRUB , , , -. /boot . , / () , LVM .

, .
send/recieve.

, GPU PCI-USB Host- KVM IOMMU.

— , .

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 में जाएंगे। हम वहां विभाजन भी नहीं बनाएंगे। यदि आप "कैनन" या "सिद्धांत" के अनुसार चाहते हैं - एक बड़ा विभाजन बनाएं, जैसे कि एचडीडी।

SATA 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 टीबी ड्राइव हैं। यह एमबीआर के लिए अनुमत सीमा के भीतर है, जिसका हम उपयोग करेंगे। यदि आवश्यक हो, तो GPT द्वारा प्रतिस्थापित किया जा सकता है। GPT डिस्क में एक संगतता परत होती है जो एमबीआर-संगत सिस्टम को पहले 4 विभाजनों को देखने की अनुमति देती है यदि वे पहले 2 गीगाबाइट के भीतर स्थित हैं। मुख्य बात यह है कि इन डिस्क पर बूट विभाजन और bios_grub विभाजन शुरुआत में होना चाहिए। यह आपको GPT लीगेसी / BIOS ड्राइव से बूट करने की अनुमति देता है।

लेकिन, यह हमारा मामला नहीं है।

यहां हम दो सेक्शन बनाएंगे। पहला आकार 1 GB होगा और इसका उपयोग RAID 1 / बूट के लिए किया जाएगा।

दूसरे का उपयोग RAID 6 के लिए किया जाएगा और ड्राइव के अंत में एक छोटे से अनअलोकेटेड क्षेत्र के अपवाद के साथ शेष सभी खाली स्थान ले लेंगे।

असिंचित क्षेत्र क्या है?

SATA SSD SLC 6 78 . 6 «» «» «» . 72 .

, SLC, 4 bit MLC. , 4 1 SLC .

72 4 288 . , SLC .

, 312 SLC . 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 .

, SSD 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

इतना बड़ा क्यों ...?

chunk-size chunk-size . , . , IOPS . 99% IO 512K.

RAID 6 IOPS IOPS . IOPS , .
RAID 6 by-design , RAID 6 .
RAID 6 NVMe thin-provisioning.

हमने RAID 6 के लिए अभी तक DISCARD को सक्षम नहीं किया है। इसलिए, हम अभी इस सरणी को "इनिशियलाइज़" नहीं करेंगे। ओएस स्थापित करने के बाद, हम इसे बाद में करेंगे।

SATA HDD

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

NVMe RAID पर LVM

गति के लिए, हम मूल FS को NVMe RAID 1 पर रखना चाहते हैं जो कि / dev / md0 है।
फिर भी, हमें अन्य आवश्यकताओं के लिए इस तेज़ सरणी की आवश्यकता है, जैसे कि स्वैप, मेटाडेटा और एलवीएम-कैश और एलवीएम-पतली मेटाडेटा, इसलिए, इस सरणी पर हम एलवीएम वीजी बनाएंगे। रूट FS के लिए एक विभाजन बनाएँ। RAM का आकार बदलने के लिए एक अनुभाग बनाएँ।

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

#lvcreate -L 128G --name root root

#lvcreate -L 32G --name swap root

ओएस स्थापना

कुल मिलाकर, हमारे पास सिस्टम को स्थापित करने के लिए आवश्यक सब कुछ है।

उबंटू लाइव वातावरण से इंस्टॉलेशन विज़ार्ड लॉन्च करें। सामान्य स्थापना। केवल स्थापना के लिए ड्राइव का चयन करने के चरण में, आपको निम्नलिखित निर्दिष्ट करने की आवश्यकता है:

/ dev / md1, - आरोह बिंदु / बूट, FS - BTRFS
/ देव / जड़ / जड़ (उर्फ / देव / मैपर / रूट-रूट), - आरोह बिंदु / (जड़), एफएस - आरटीआरएफएस
/ देव / जड़ / स्वैप (उर्फ / देव / मैपर / रूट-स्वैप), - स्वैप विभाजन के रूप में उपयोग करें
बूटलोडर / देव / एसडीए पर स्थापित करें

यदि आप BTRFS को रूट FS के रूप में चुनते हैं, तो इंस्टॉलर स्वचालित रूप से / (घर) के लिए "@" और "@home" नाम के साथ दो BTRFS वॉल्यूम बनाएगा।

हम इंस्टालेशन शुरू करते हैं ...

इंस्टालेशन बूट लोडर इंस्टॉलेशन एरर के बारे में सूचित करते हुए एक मोडल डायलॉग बॉक्स के साथ समाप्त होगा। दुर्भाग्य से, नियमित रूप से इस संवाद से बाहर निकलना और स्थापना जारी रखना विफल हो जाएगा। हम सिस्टम से बाहर लॉग इन करते हैं और फिर से साफ उबंटू लाइव डेस्कटॉप में प्रवेश करते हैं। टर्मिनल खोलें, और फिर से:

#sudo bash

इंस्टॉलेशन जारी रखने के लिए एक चेरोट वातावरण बनाएं : चेरोट में नेटवर्क और होस्टनाम सेट करें: चेरोट पर्यावरण पर जाएं: पहले हम पैकेज वितरित करते हैं: सिस्टम के अधूरे इंस्टॉलेशन के कारण टेढ़े-मेढ़े सभी पैकेजों की जाँच करें और उन्हें ठीक करें:

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

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

#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/source.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=="sd[a-z]", ATTR{queue/rotational}=="0", RUN+="/sbin/blockdev --setra 0 /dev/%k"
SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="nvme[0-9]n1", RUN+="/sbin/blockdev --setra 0 /dev/%k"
SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="dm-*", ATTR{queue/rotational}=="0", RUN+="/sbin/blockdev --setra 0 /dev/%k"
SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="md*", RUN+="/sbin/blockdev --setra 0 /dev/%k"

EOF

यह क्या था..?

udev :

2020- RAID 6. -, , Linux, .
/ IO. , .
/ IO. , / SSD RAID- . NVMe. ( ? . )
APM (HDD) 7 . APM (-B 255). - . , , , -. . - . , , - «», -, RAID- mini-MAID-.
readahead () 1 — /chunk RAID 6
readahead SATA SSD
readahead NVMe SSD
readahead LVM SSD.
readahead RAID .

संपादित करें / 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 .

दो बार हम माउंट / देव / मैपर / रूट-रूट ..?

. . BTRFS. subvol.

- LVM BTRFS . .

हम mdadm कॉन्फिगरेशन को पुनः प्राप्त करते हैं: LVM सेटिंग्स को ठीक करें:

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

#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 thin 90% 5% .

LVM cache.

LVM LVM (PV) :

LVM cache (cdata)
LVM cache (<lv_name>_corig). ( <lv_name>).
LVM cache (cmeta)
VG images. , , LVM .
VG backup. .
«gpv» ( guest physical volume )

DISCARD LVM VG. . LV SSD . SSD RAID 6. , , thin provisioning, , .

Initramfs छवि अपडेट

#update-initramfs -u -k all

करें: ग्रब स्थापित करें और कॉन्फ़िगर करें:

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

चुनने के लिए क्या ड्राइव?

sd*. SATA SSD.

क्यों ओस-prober ..?

.

RAID- . , .

, , , . .

इसके साथ, हमने प्रारंभिक स्थापना पूरी की। यह नए स्थापित ओएस में रिबूट करने का समय है। बूट करने योग्य लाइव सीडी / यूएसबी को हटाने के लिए याद रखें। बूट करने के लिए एक उपकरण के रूप में, SATA SSD में से किसी का चयन करें।

#exit
#reboot

LVM SATA SSD को

इस बिंदु पर, हमने पहले से ही नए ओएस में बूट किया है, नेटवर्क को कॉन्फ़िगर किया है, उपयुक्त, टर्मिनल एमुलेटर खोला है, और शुरू किया:

#sudo bash

जारी रखें।

SATA SSD से एक सरणी "आरंभ करें":

#blkdiscard /dev/md2

यदि यह नहीं है, तो प्रयास करें:

#blkdiscard --step 65536 /dev/md2
SBS SSD पर LVM VG बनाएँ:

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

क्यों एक और वीजी ..?

, VG root. VG?

VG PV, VG PV (online). LVM RAID, .

, ( ) RAID 6 .

, «» VG.

-, RAID « ». , VG.

LVM «» RAID - . , — bcache + LVM thin, bcache + BTRFS, LVM cache + LVM thin, ZFS , .

«» , - «» LVM-, . , , .

, , - .

LVM SATA HDD को

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

फिर से नया वीजी ..?

, , , , - . , - VG, — VG.

LVM कैश कॉन्फ़िगर करें

एक कैशिंग डिवाइस के रूप में उपयोग करने के लिए NVMe RAID 1 पर LV बनाएं।

#lvcreate -L 70871154688B --name cache root

इतना कम क्यों ...?

, NVMe SSD SLC . 4 «» 18 3-bit MLC. - NVMe SSD SATA SSD . , LVM cache SLC NVMe . NVMe 32-64 .

64 , .

, LVM . , lvchange . , .

चलो एक कैश्ड डिवाइस के रूप में उपयोग करने के लिए SATA RAID 6 पर LV बनाएं।

#lvcreate -L 3298543271936B --name cache data

केवल तीन टेराबाइट्स ही क्यों ..?

, , SATA SSD RAID 6 - . , , . , , LVM-cache , , bcache, , .

कैशिंग के लिए एक नया वीजी बनाएं। कैश्ड डिवाइस पर LV बनाएं। यहां हमने तुरंत / dev / data / cache पर सभी खाली स्थान ले लिए ताकि अन्य सभी आवश्यक विभाजन तुरंत / dev / root / कैश पर बनाए जा सकें। यदि आपके पास वहाँ कुछ नहीं बना है, तो आप इसे pvmove का उपयोग करके स्थानांतरित कर सकते हैं। कैश बनाएं और सक्षम करें:

#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

#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 cache LVM thin. , , .

64 — LVM thin.

सावधानी लिखावट ..!

. . , , , . , , NVMe RAID 1 , .

, RAID 6 .

यह सत्यापित करें कि हम सफल हुए: केवल [cachedata_corig] / dev / data / cache पर स्थित होना चाहिए। अगर कुछ गलत है, तो pvmove का उपयोग करें। यदि आवश्यक हो, तो आप कैश को एक कमांड के साथ अक्षम कर सकते हैं: यह ऑन-लाइन किया जाता है। LVM केवल कैश को डिस्क में सिंक करता है, उसे हटाता है, और cachedata_corig को वापस कैश्डेट करता है।

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

#lvconvert -y --uncache cache/cachedata

LVM पतली सेटअप

हम मोटे तौर पर अनुमान लगाते हैं कि हमें LVM पतली मेटाडेटा के लिए कितनी जगह की आवश्यकता होगी: 4 गीगाबाइट तक गोल करें : 4294967296B दो से गुणा करें और LVM मेटाडेटा PV के लिए 4194304B जोड़ें: 85M128896B LVM पतली मेटाडेटा को चिह्नित करने के लिए NVMe RAID 1 पर एक अलग विभाजन बनाएँ और इसका बैक अप लें।

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

#lvcreate -L 8594128896B --name images root

किस लिए..?

, LVM thin , NVMe .

, . , , . - , , LVM thin , . .

- -, , , . , . .

, , , , , , LVM thin, .

एक नया वीजी बनाएं जो पतले प्रावधान के लिए जिम्मेदार होगा: एक पूल बनाएं:

#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

क्यों -जेड वाई

, , — , — zeroing 64k. 64k 64K . .

चलो LV को संबंधित 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=256Kwrite --bs=256k --rw=write \
--name=128Kwrite --bs=128k --rw=write \
--name=64Kwrite --bs=64k --rw=write \
--name=32Kwrite --bs=32k --rw=write \
--name=16Kwrite --bs=16k --rw=write \
--name=8Kwrite --bs=8k --rw=write \
--name=4Kwrite --bs=4k --rw=write \
--name=512KQD32write --bs=512k --iodepth=32 --rw=randwrite \
--name=256KQD32write --bs=256k --iodepth=32 --rw=randwrite \
--name=128KQD32write --bs=128k --iodepth=32 --rw=randwrite \
--name=64KQD32write --bs=64k --iodepth=32 --rw=randwrite \
--name=32KQD32write --bs=32k --iodepth=32 --rw=randwrite \
--name=16KQD32write --bs=16k --iodepth=32 --rw=randwrite \
--name=8KQD32write --bs=8k --iodepth=32 --rw=randwrite \
--name=4kQD32write --bs=4k --iodepth=32 --rw=randwrite \
| grep -E 'read|write|test' | grep -v ioengine

सावधान! संसाधन!

36 , 4 . . 4 NVMe . 3 . , 216 SSD.

पढ़ना और लिखना फेरबदल?

. . , , , .

परिणाम पहली शुरुआत में और बाद में अलग-अलग होंगे क्योंकि कैश और पतली मात्रा भरते हैं, और यह भी, इस पर निर्भर करता है कि क्या सिस्टम अंतिम शुरुआत में भरे गए कैश को सिंक्रनाइज़ करने में कामयाब रहा।

अन्य बातों के अलावा, मैं पहले से भरे पतले वॉल्यूम पर गति को मापने की सलाह देता हूं जिससे स्नैपशॉट अभी बनाया गया है। लेखक के पास यह देखने का अवसर था कि पहले स्नैपशॉट बनाने के तुरंत बाद कैसे एक यादृच्छिक रिकॉर्डिंग तेजी से बढ़ती है, खासकर जब कैश अभी तक भरा नहीं है। यह लिखने के कॉपी-ऑन-राइट सेमेंटिक्स, कैश ब्लॉक और पतले वॉल्यूम के संरेखण के कारण है, और यह तथ्य कि रैंड 6 पर रैंडम राइट राउड 6 से रैंडम रीड में बदल जाता है और फिर कैशे से लिखता है। हमारे कॉन्फ़िगरेशन में, रैंड 6 से 6 गुना तक यादृच्छिक पढ़ा (सरणी में SATA SSDs की संख्या) लिखने की तुलना में तेज है। चूंकि चूंकि सीओडब्ल्यू ब्लॉक को एक पतली पूल से क्रमिक रूप से आवंटित किया जाता है, इसलिए अधिकांश भाग के लिए रिकॉर्ड भी एक क्रमिक में बदल जाता है।

इन दोनों सुविधाओं का लाभ उठाया जा सकता है।

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

कैश की क्षति / हानि के मामले में डेटा हानि के जोखिम को कम करने के लिए, लेखक इस मामले में उनकी अखंडता की गारंटी के लिए स्नैपशॉट को घुमाने की प्रथा शुरू करने का सुझाव देता है।

सबसे पहले, इस तथ्य के कारण कि पतले संस्करणों के मेटाडेटा एक अनछुए डिवाइस पर स्थित हैं, मेटाडेटा सुसंगत होगा और संभव नुकसान डेटा ब्लॉक के अंदर अलग हो जाएंगे।

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

नाम के साथ प्रत्येक पतली मात्रा के लिए <name>, <name> .cached नाम के साथ एक स्नैपशॉट बनाएं
माइग्रेशन सीमा को उचित उच्च मान पर सेट करें: #lvchange --quiet --cachesettings "migration_threshold=16384" cache/cachedata
: #lvs --rows --reportformat basic --quiet -ocache_dirty_blocks cache/cachedata | awk '{print $2}' . , writethrough . , SATA NVMe SSD, , TBW, , . - 100% . NVMe SSD 100% 3-4 . SATA SSD - . , , , , — .
( ) — <>.cached <>.committed. <>.committed .
, 100%, , . .
migration threshold : #lvchange --quiet --cachesettings "migration_threshold=0" cache/cachedata .
, #lvs --rows --reportformat basic --quiet -ocache_dirty_blocks cache/cachedata | awk '{print $2}' .
.

migration threshold...?

, «» . - 4 , , - (+- 32K) .

migration threshold SATA SSD 64K . SATA SSD.

..?

, bash 100% «google»-driven development, , , , .

, , , , systemd , .

स्नैपशॉट के लिए इस तरह की एक सरल रोटेशन योजना हमें न केवल लगातार एक स्नैपशॉट को SATA SSD पर पूरी तरह से सिंक्रनाइज़ करने की अनुमति देगी, बल्कि पतले_डेलटा उपयोगिता की मदद से यह पता लगाने के लिए कि इसके निर्माण के बाद कौन से ब्लॉक बदले गए थे, और इस तरह मुख्य वॉल्यूम पर नुकसान का स्थानीयकरण किया गया, जिससे इसे बहाल करना बहुत आसान हो गया। ।

TRIM / DISCARD in libvirt / KVM

चूंकि चूँकि डेटा वेयरहाउस का उपयोग केवीएम चलाने वाले libvirt के लिए किया जाएगा, इसलिए हमारे वीएम को न केवल मुफ्त स्थान लेना सिखाना अच्छा होगा, बल्कि यह भी मुफ़्त होगा कि अब इसकी आवश्यकता नहीं है।

यह वर्चुअल डिस्क पर TRIM / DISCARD समर्थन का अनुकरण करके किया जाता है। ऐसा करने के लिए, नियंत्रक प्रकार को गुण-स्कैसी में बदलें और xml को संपादित करें। अतिथि OS से इसी तरह के DISCARDs को LVM द्वारा सही तरीके से संसाधित किया जाता है, और ब्लॉक कैश और पतले पूल में दोनों को सही ढंग से मुक्त किया जाता है। हमारे मामले में, यह तब होता है, जब आप अगले स्नैपशॉट को हटाते हैं, मुख्य रूप से स्थगित हो जाता है।

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

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

BTRFS बैकअप

अत्यधिक सावधानी और जोखिम और जोखिम के साथ तैयार लिपियों का उपयोग करें । लेखक ने यह कोड स्वयं और विशेष रूप से स्वयं के लिए लिखा था। मुझे यकीन है कि कई अनुभवी लिनक्स उपयोगकर्ताओं के पास अनुभव के ऐसे ~~बैसाखी~~ हैं, और दूसरों की प्रतिलिपि बनाने की आवश्यकता नहीं होगी।

बैकअप डिवाइस पर एक वॉल्यूम बनाएँ:

#lvcreate -L 256G --name backup backup

इसे BTRFS में फ़ॉर्मेट

#mkfs.btrfs /dev/backup/backup

करें : माउंट पॉइंट बनाएँ और रूट रूट उप FS की FS: बैकअप के लिए निर्देशिका बनाएँ : बैकअप स्क्रिप्ट के लिए एक निर्देशिका बनाएँ: स्क्रिप्ट की प्रतिलिपि बनाएँ :

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

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

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

#mkdir /root/btrfs-backup

ढेर सारा डरावना कोड। अपने जोखिम पार इस्तेमाल करें। लेखक नाराज पत्र नहीं लिखता है ...

#cat >/root/btrfs-backup/btrfs-backup.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

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

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

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

function wait_lock()
{
flock 98
}

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

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

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

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

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

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

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

}

(
COMMAND="$1"
shift

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

EOF

यह भी क्या करता है ..?

BTRFS BTRFS send/recieve.

पहला लॉन्च अपेक्षाकृत लंबा हो सकता है, क्योंकि शुरुआत में सभी डेटा की प्रतिलिपि बनाई जाएगी। आगे की शुरूआत बहुत तेज होगी, क्योंकि केवल परिवर्तनों की प्रतिलिपि बनाई जाएगी।

क्रोन में रटना करने के लिए एक और स्क्रिप्ट:

कुछ और बैश कोड

#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

यह क्या कर रहा हैं ..?

backup BTRFS-. 60 . /backup/btrfs/back/remote/ .

आइए कोड को निष्पादित करने का अधिकार दें: मुकुट में चेक और रटना:

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

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

LVM पतली बैकअप

बैकअप डिवाइस पर एक पतली पूल बनाएँ:

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

ddrescue स्थापित करें, क्योंकि स्क्रिप्ट इस टूल का उपयोग करेंगे:

#apt-get install gddrescue

स्क्रिप्ट के लिए एक निर्देशिका बनाएँ: स्क्रिप्ट की

#mkdir /root/lvm-thin-backup

प्रतिलिपि बनाएँ:

अंदर बहुत सारी मार ...

#cat >/root/lvm-thin-backup/lvm-thin-backup.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

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

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

export LVM_SUPPRESS_FD_WARNINGS=1

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

function wait_lock()
{
flock 98
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

dmsetup message $DIFF_POOL_PATH_TPOOL 0 release_metadata_snap

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

}

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

activate_volume $SYNC_VG $SYNC_PEND

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

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

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

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

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

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

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

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

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

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

echo Syncronizing "$SOURCE_BASE_LV_PATH" to "$TARGET_BASE_LV_PATH"

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

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

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

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

}

(
COMMAND="$1"
shift

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

EOF

यह क्या कर रहा हैं ...?

, thin_delta, ddrescue blkdiscard.

एक और पटकथा जिसे हम मुकुट में पिरोएंगे:

कुछ और बैश

#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

यह क्या कर रहा हैं ...?

, . , .

इस स्क्रिप्ट को संपादित करने की आवश्यकता है, जिसमें पतली वॉल्यूम की एक सूची का संकेत मिलता है जिसके लिए बैकअप की आवश्यकता होती है। दिए गए नाम केवल चित्रण प्रयोजनों के लिए हैं। यदि आप चाहें, तो आप एक स्क्रिप्ट लिख सकते हैं जो सभी संस्करणों को सिंक्रनाइज़ करेगा।

आइए अधिकार दें: मुकुट में चेक और रटना: पहला लॉन्च लंबा होगा, क्योंकि पतले संस्करणों को पूरी तरह से उपयोग किए गए स्थान की नकल करके पूरी तरह से सिंक्रनाइज़ किया जाएगा। LVM पतली मेटाडेटा के लिए धन्यवाद, हम जानते हैं कि कौन से ब्लॉक वास्तव में उपयोग किए जाते हैं, इसलिए पतले वॉल्यूम के केवल वास्तविक ब्लॉक की प्रतिलिपि बनाई जाएगी। इसके बाद के प्रक्षेपण LVM पतली मेटाडेटा के माध्यम से परिवर्तनों को ट्रैक करके डेटा को बड़े पैमाने पर कॉपी करेंगे।

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

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

देखते है क्या हुआ:

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

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

#ls -al /backup/btrfs/back/remote/*
/backup/btrfs/back/remote/boot:
total 0
drwxr-xr-x 1 root root 1260 26 09:11 .
drwxr-xr-x 1 root root 16 6 09:30 ..
drwxr-xr-x 1 root root 322 26 02:00 .@base
drwxr-xr-x 1 root root 516 6 09:39 .@snap.2020-03-06-09-39-37
drwxr-xr-x 1 root root 516 6 09:39 .@snap.2020-03-06-09-39-57
...
/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 @home.@snap.2020-03-06-09-39-35
drwxr-xr-x 1 root root 22 6 09:39 @home.@snap.2020-03-06-09-39-57
...
drwxr-xr-x 1 root root 240 6 09:39 @.@snap.2020-03-06-09-39-26
drwxr-xr-x 1 root root 240 6 09:39 @.@snap.2020-03-06-09-39-56
...

#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 पुनरावर्ती हो सकता है, घोंसले के शिकार गुड़िया की तरह। इससे LVM को अत्यधिक लचीलापन मिलता है।

पुनश्च

अगले लेख में, हम होम डेस्कटॉप, होम इंटरनेट और पी 2 पी नेटवर्क के माध्यम से कई महाद्वीपों पर अतिरेक के साथ भू-वितरित भंडारण / वीएम क्लस्टर बनाने के आधार के रूप में कई समान मोबाइल स्टोरेज सिस्टम / केवीएम का उपयोग करने का प्रयास करेंगे।

LVM और matryoshka के बीच क्या आम है?

बयान

लोहा

स्टॉक में था:

इसके अतिरिक्त यह जोड़ा गया था:

मुलायम

स्थापना की तैयारी

विभाजन "ड्राइव"

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

SATA HDD

SATA SSD

ऐरे बनाना

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

SATA SSD

SATA HDD

NVMe RAID पर LVM

ओएस स्थापना

LVM SATA SSD को

LVM SATA HDD को

LVM कैश कॉन्फ़िगर करें

LVM पतली सेटअप

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

TRIM / DISCARD in libvirt / KVM

BTRFS बैकअप

LVM पतली बैकअप

देखते है क्या हुआ:

और घोंसले के शिकार गुड़िया के बारे में क्या?

पुनश्च

More articles: