LVM ਅਤੇ Matryoshka ਵਿੱਚ ਕੀ ਸਮਾਨ ਹੈ?

ਤੁਹਾਡਾ ਦਿਨ ਚੰਗਾ ਲੰਘੇ.
ਮੈਂ md RAID + LVM ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ KVM ਲਈ ਡਾਟਾ ਸਟੋਰੇਜ ਸਿਸਟਮ ਬਣਾਉਣ ਦਾ ਆਪਣਾ ਵਿਹਾਰਕ ਅਨੁਭਵ ਕਮਿਊਨਿਟੀ ਨਾਲ ਸਾਂਝਾ ਕਰਨਾ ਚਾਹਾਂਗਾ।

ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣਗੇ:

• NVMe SSD ਤੋਂ md RAID 1 ਬਣਾਉਣਾ।
• SATA SSD ਅਤੇ ਨਿਯਮਤ ਡਰਾਈਵਾਂ ਤੋਂ md RAID 6 ਨੂੰ ਅਸੈਂਬਲ ਕਰਨਾ।
• SSD RAID 1/6 'ਤੇ TRIM/DSCARD ਓਪਰੇਸ਼ਨ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ।
• ਡਿਸਕ ਦੇ ਇੱਕ ਆਮ ਸੈੱਟ ਉੱਤੇ ਬੂਟ ਹੋਣ ਯੋਗ md RAID 1/6 ਐਰੇ ਬਣਾਉਣਾ।
• NVMe RAID 1 ਉੱਤੇ ਸਿਸਟਮ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨਾ ਜਦੋਂ BIOS ਵਿੱਚ ਕੋਈ NVMe ਸਹਿਯੋਗ ਨਹੀਂ ਹੈ।
• LVM ਕੈਸ਼ ਅਤੇ LVM ਪਤਲੇ ਦੀ ਵਰਤੋਂ ਕਰਨਾ।
• BTRFS ਸਨੈਪਸ਼ਾਟ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਅਤੇ ਬੈਕਅੱਪ ਲਈ ਭੇਜੋ/ਪ੍ਰਾਪਤ ਕਰੋ।
• BTRFS ਸ਼ੈਲੀ ਬੈਕਅੱਪ ਲਈ LVM ਪਤਲੇ ਸਨੈਪਸ਼ਾਟ ਅਤੇ thin_delta ਦੀ ਵਰਤੋਂ ਕਰਨਾ।

ਜੇ ਤੁਸੀਂ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਬਿੱਲੀ ਨੂੰ ਦੇਖੋ।

ਬਿਆਨ

ਲੇਖਕ ਇਸ ਲੇਖ ਤੋਂ ਸਮੱਗਰੀ/ਉਦਾਹਰਨਾਂ/ਕੋਡ/ਸੁਝਾਅ/ਡਾਟੇ ਦੀ ਵਰਤੋਂ ਕਰਨ ਜਾਂ ਨਾ ਕਰਨ ਦੇ ਨਤੀਜਿਆਂ ਲਈ ਕੋਈ ਜ਼ਿੰਮੇਵਾਰੀ ਨਹੀਂ ਲੈਂਦਾ। ਇਸ ਸਮੱਗਰੀ ਨੂੰ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਪੜ੍ਹ ਕੇ ਜਾਂ ਵਰਤ ਕੇ, ਤੁਸੀਂ ਇਹਨਾਂ ਕਾਰਵਾਈਆਂ ਦੇ ਸਾਰੇ ਨਤੀਜਿਆਂ ਲਈ ਜ਼ਿੰਮੇਵਾਰੀ ਲੈਂਦੇ ਹੋ। ਸੰਭਾਵੀ ਨਤੀਜਿਆਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

• ਕਰਿਸਪ-ਤਲੇ ਹੋਏ NVMe SSDs।
• ਰਿਕਾਰਡਿੰਗ ਸਰੋਤ ਅਤੇ SSD ਡਰਾਈਵਾਂ ਦੀ ਅਸਫਲਤਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵਰਤੀ ਗਈ।
• ਬੈਕਅੱਪ ਕਾਪੀਆਂ ਸਮੇਤ ਸਾਰੀਆਂ ਡਰਾਈਵਾਂ 'ਤੇ ਸਾਰੇ ਡਾਟੇ ਦਾ ਪੂਰਾ ਨੁਕਸਾਨ।
• ਨੁਕਸਦਾਰ ਕੰਪਿਊਟਰ ਹਾਰਡਵੇਅਰ।
• ਸਮਾਂ, ਨਸਾਂ ਅਤੇ ਪੈਸੇ ਦੀ ਬਰਬਾਦੀ.
• ਕੋਈ ਵੀ ਹੋਰ ਨਤੀਜੇ ਜੋ ਉੱਪਰ ਸੂਚੀਬੱਧ ਨਹੀਂ ਹਨ।

ਆਇਰਨ

ਉਪਲਬਧ ਸਨ:

Z2013 ਚਿੱਪਸੈੱਟ ਦੇ ਨਾਲ ਲਗਭਗ 87 ਤੋਂ ਮਦਰਬੋਰਡ, Intel Core i7 / Haswell ਨਾਲ ਪੂਰਾ।

• ਪ੍ਰੋਸੈਸਰ 4 ਕੋਰ, 8 ਥਰਿੱਡ
• 32 GB DDR3 ਰੈਮ
• 1 x 16 ਜਾਂ 2 x 8 PCIe 3.0
• 1 x 4 + 1 x 1 PCIe 2.0
• 6 x 6 GBps SATA 3 ਕਨੈਕਟਰ

SAS ਅਡਾਪਟਰ LSI SAS9211-8I IT/HBA ਮੋਡ 'ਤੇ ਫਲੈਸ਼ ਹੋਇਆ। RAID-ਸਮਰੱਥ ਫਰਮਵੇਅਰ ਨੂੰ ਜਾਣਬੁੱਝ ਕੇ HBA ਫਰਮਵੇਅਰ ਨਾਲ ਬਦਲਿਆ ਗਿਆ ਹੈ:

1. ਤੁਸੀਂ ਇਸ ਅਡੈਪਟਰ ਨੂੰ ਕਿਸੇ ਵੀ ਸਮੇਂ ਬਾਹਰ ਸੁੱਟ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸ ਨੂੰ ਕਿਸੇ ਹੋਰ ਨਾਲ ਬਦਲ ਸਕਦੇ ਹੋ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਦੇਖਿਆ ਸੀ।
2. TRIM/Discard ਆਮ ਤੌਰ 'ਤੇ ਡਿਸਕਾਂ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ, ਕਿਉਂਕਿ... RAID ਫਰਮਵੇਅਰ ਵਿੱਚ ਇਹ ਕਮਾਂਡਾਂ ਬਿਲਕੁਲ ਵੀ ਸਮਰਥਿਤ ਨਹੀਂ ਹਨ, ਅਤੇ HBA, ਆਮ ਤੌਰ 'ਤੇ, ਇਸ ਗੱਲ ਦੀ ਪਰਵਾਹ ਨਹੀਂ ਕਰਦਾ ਕਿ ਬੱਸ ਵਿੱਚ ਕਿਹੜੀਆਂ ਕਮਾਂਡਾਂ ਪ੍ਰਸਾਰਿਤ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

ਹਾਰਡ ਡਰਾਈਵਾਂ - 8 ਫਾਰਮ ਫੈਕਟਰ ਵਿੱਚ 7 ਟੀਬੀ ਦੀ ਸਮਰੱਥਾ ਵਾਲੇ HGST Travelstar 1000K1 ਦੇ 2.5 ਟੁਕੜੇ, ਜਿਵੇਂ ਕਿ ਲੈਪਟਾਪਾਂ ਲਈ। ਇਹ ਡਰਾਈਵਾਂ ਪਹਿਲਾਂ ਇੱਕ RAID 6 ਐਰੇ ਵਿੱਚ ਸਨ। ਨਵੀਂ ਪ੍ਰਣਾਲੀ ਵਿਚ ਇਨ੍ਹਾਂ ਦੀ ਵਰਤੋਂ ਵੀ ਹੋਵੇਗੀ। ਸਥਾਨਕ ਬੈਕਅੱਪ ਸਟੋਰ ਕਰਨ ਲਈ.

ਇਸ ਤੋਂ ਇਲਾਵਾ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ:

6 ਟੁਕੜੇ SATA SSD ਮਾਡਲ ਸੈਮਸੰਗ 860 QVO 2TB. ਇਹਨਾਂ SSD ਨੂੰ ਇੱਕ ਵੱਡੀ ਮਾਤਰਾ ਦੀ ਲੋੜ ਸੀ, ਇੱਕ SLC ਕੈਸ਼ ਦੀ ਮੌਜੂਦਗੀ, ਭਰੋਸੇਯੋਗਤਾ, ਅਤੇ ਇੱਕ ਘੱਟ ਕੀਮਤ ਦੀ ਲੋੜ ਸੀ। ਰੱਦ/ਜ਼ੀਰੋ ਲਈ ਸਮਰਥਨ ਦੀ ਲੋੜ ਸੀ, ਜੋ ਕਿ dmesg ਵਿੱਚ ਲਾਈਨ ਦੁਆਰਾ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ:

kernel: ata1.00: Enabling discard_zeroes_data

NVMe SSD ਮਾਡਲ ਸੈਮਸੰਗ SSD 2 EVO 970GB ਦੇ 500 ਟੁਕੜੇ।

ਇਹਨਾਂ SSDs ਲਈ, ਤੁਹਾਡੀਆਂ ਲੋੜਾਂ ਲਈ ਬੇਤਰਤੀਬ ਪੜ੍ਹਨ/ਲਿਖਣ ਦੀ ਗਤੀ ਅਤੇ ਸਰੋਤ ਸਮਰੱਥਾ ਮਹੱਤਵਪੂਰਨ ਹਨ। ਉਹਨਾਂ ਲਈ ਰੇਡੀਏਟਰ. ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ. ਬਿਲਕੁਲ। ਨਹੀਂ ਤਾਂ, ਪਹਿਲੀ ਰੇਡ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਦੌਰਾਨ ਉਹਨਾਂ ਨੂੰ ਕਰਿਸਪੀ ਹੋਣ ਤੱਕ ਫ੍ਰਾਈ ਕਰੋ।

StarTech PEX8M2E2 ਅਡਾਪਟਰ 2 x NVMe SSD ਲਈ PCIe 3.0 8x ਸਲਾਟ ਵਿੱਚ ਸਥਾਪਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ, ਦੁਬਾਰਾ, ਸਿਰਫ ਇੱਕ HBA ਹੈ, ਪਰ NVMe ਲਈ. ਇਹ ਸਸਤੇ ਅਡਾਪਟਰਾਂ ਤੋਂ ਵੱਖਰਾ ਹੈ ਕਿਉਂਕਿ ਇਸਨੂੰ ਬਿਲਟ-ਇਨ PCIe ਸਵਿੱਚ ਦੀ ਮੌਜੂਦਗੀ ਦੇ ਕਾਰਨ ਮਦਰਬੋਰਡ ਤੋਂ PCIe ਬਾਇਫਰਕੇਸ਼ਨ ਸਮਰਥਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਇਹ PCIe ਦੇ ਨਾਲ ਸਭ ਤੋਂ ਪੁਰਾਣੇ ਸਿਸਟਮ ਵਿੱਚ ਵੀ ਕੰਮ ਕਰੇਗਾ, ਭਾਵੇਂ ਇਹ ਇੱਕ x1 PCIe 1.0 ਸਲਾਟ ਹੋਵੇ। ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, ਉਚਿਤ ਗਤੀ 'ਤੇ. ਉੱਥੇ ਕੋਈ ਰੇਡ ਨਹੀਂ ਹਨ। ਬੋਰਡ 'ਤੇ ਕੋਈ ਬਿਲਟ-ਇਨ BIOS ਨਹੀਂ ਹੈ। ਇਸ ਲਈ, ਤੁਹਾਡਾ ਸਿਸਟਮ ਜਾਦੂਈ ਢੰਗ ਨਾਲ NVMe ਨਾਲ ਬੂਟ ਕਰਨਾ ਨਹੀਂ ਸਿੱਖੇਗਾ, ਇਸ ਡਿਵਾਈਸ ਲਈ NVMe RAID ਦਾ ਧੰਨਵਾਦ ਬਹੁਤ ਘੱਟ ਹੈ।

ਇਹ ਕੰਪੋਨੈਂਟ ਸਿਸਟਮ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ ਮੁਫ਼ਤ 8x PCIe 3.0 ਦੀ ਮੌਜੂਦਗੀ ਦੇ ਕਾਰਨ ਸੀ, ਅਤੇ, ਜੇਕਰ 2 ਮੁਫ਼ਤ ਸਲਾਟ ਹਨ, ਤਾਂ ਇਸਨੂੰ ਆਸਾਨੀ ਨਾਲ ਦੋ ਪੈਨੀ PEX4M2E1 ਜਾਂ ਐਨਾਲਾਗ ਨਾਲ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ 600 ਦੀ ਕੀਮਤ 'ਤੇ ਕਿਤੇ ਵੀ ਖਰੀਦਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਰੂਬਲ

ਹਰ ਕਿਸਮ ਦੇ ਹਾਰਡਵੇਅਰ ਜਾਂ ਬਿਲਟ-ਇਨ ਚਿੱਪਸੈੱਟ/BIOS ਰੇਡਾਂ ਨੂੰ ਅਸਵੀਕਾਰ ਕਰਨਾ ਜਾਣਬੁੱਝ ਕੇ ਕੀਤਾ ਗਿਆ ਸੀ, ਤਾਂ ਜੋ ਸਾਰੇ ਡੇਟਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦੇ ਹੋਏ, SSD/HDD ਦੇ ਅਪਵਾਦ ਦੇ ਨਾਲ, ਪੂਰੇ ਸਿਸਟਮ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬਦਲਣ ਦੇ ਯੋਗ ਬਣਾਇਆ ਜਾ ਸਕੇ। ਆਦਰਸ਼ਕ ਤੌਰ 'ਤੇ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਵੇਂ/ਵੱਖਰੇ ਹਾਰਡਵੇਅਰ 'ਤੇ ਜਾਣ ਵੇਲੇ ਸਥਾਪਤ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੂੰ ਵੀ ਬਚਾ ਸਕੋ। ਮੁੱਖ ਗੱਲ ਇਹ ਹੈ ਕਿ ਇੱਥੇ SATA ਅਤੇ PCIe ਪੋਰਟ ਹਨ. ਇਹ ਇੱਕ ਲਾਈਵ ਸੀਡੀ ਜਾਂ ਬੂਟ ਹੋਣ ਯੋਗ ਫਲੈਸ਼ ਡਰਾਈਵ ਵਰਗਾ ਹੈ, ਸਿਰਫ ਬਹੁਤ ਤੇਜ਼ ਅਤੇ ਥੋੜਾ ਜਿਹਾ ਭਾਰੀ।

ਹਾਸੇਨਹੀਂ ਤਾਂ, ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਕੀ ਹੁੰਦਾ ਹੈ - ਕਈ ਵਾਰ ਤੁਹਾਨੂੰ ਤੁਰੰਤ ਆਪਣੇ ਨਾਲ ਪੂਰੀ ਐਰੇ ਲੈ ਕੇ ਜਾਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਪਰ ਮੈਂ ਡਾਟਾ ਗੁਆਉਣਾ ਨਹੀਂ ਚਾਹੁੰਦਾ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਾਰੇ ਜ਼ਿਕਰ ਕੀਤੇ ਮੀਡੀਆ ਮਿਆਰੀ ਕੇਸ ਦੇ 5.25 ਬੇਸ ਵਿੱਚ ਸਲਾਈਡਾਂ 'ਤੇ ਸੁਵਿਧਾਜਨਕ ਤੌਰ' ਤੇ ਸਥਿਤ ਹਨ.

ਖੈਰ, ਅਤੇ, ਬੇਸ਼ਕ, ਲੀਨਕਸ ਵਿੱਚ SSD ਕੈਚਿੰਗ ਦੇ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਨ ਲਈ.

ਹਾਰਡਵੇਅਰ ਛਾਪੇ ਬੋਰਿੰਗ ਹਨ. ਇਸਨੂੰ ਚਾਲੂ ਕਰੋ। ਇਹ ਜਾਂ ਤਾਂ ਕੰਮ ਕਰਦਾ ਹੈ ਜਾਂ ਨਹੀਂ ਕਰਦਾ. ਅਤੇ mdadm ਨਾਲ ਹਮੇਸ਼ਾ ਵਿਕਲਪ ਹੁੰਦੇ ਹਨ।

ਸੌਫਟ

ਪਹਿਲਾਂ, ਡੇਬੀਅਨ 8 ਜੈਸੀ ਹਾਰਡਵੇਅਰ 'ਤੇ ਸਥਾਪਿਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਜੋ ਕਿ ਈਓਐਲ ਦੇ ਨੇੜੇ ਹੈ। RAID 6 ਨੂੰ LVM ਨਾਲ ਜੋੜੀ ਉਪਰੋਕਤ HDDs ਤੋਂ ਇਕੱਠਾ ਕੀਤਾ ਗਿਆ ਸੀ। ਇਹ kvm/libvirt ਵਿੱਚ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਚਲਾਉਂਦਾ ਹੈ।

ਕਿਉਂਕਿ ਲੇਖਕ ਨੂੰ ਪੋਰਟੇਬਲ ਬੂਟ ਹੋਣ ਯੋਗ SATA/NVMe ਫਲੈਸ਼ ਡਰਾਈਵਾਂ ਬਣਾਉਣ ਦਾ ਢੁਕਵਾਂ ਤਜਰਬਾ ਹੈ, ਅਤੇ ਨਾਲ ਹੀ, ਆਮ ਐਪਟ ਟੈਂਪਲੇਟ ਨੂੰ ਨਾ ਤੋੜਨ ਲਈ, ਉਬੰਟੂ 18.04 ਨੂੰ ਟਾਰਗੇਟ ਸਿਸਟਮ ਵਜੋਂ ਚੁਣਿਆ ਗਿਆ ਸੀ, ਜੋ ਪਹਿਲਾਂ ਹੀ ਕਾਫੀ ਸਥਿਰ ਹੋ ਚੁੱਕਾ ਹੈ, ਪਰ ਅਜੇ ਵੀ 3 ਸਾਲ ਦਾ ਸਮਾਂ ਹੈ। ਭਵਿੱਖ ਵਿੱਚ ਸਹਾਇਤਾ.

ਜ਼ਿਕਰ ਕੀਤੇ ਸਿਸਟਮ ਵਿੱਚ ਉਹ ਸਾਰੇ ਹਾਰਡਵੇਅਰ ਡ੍ਰਾਈਵਰ ਹੁੰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਦੀ ਸਾਨੂੰ ਬਾਕਸ ਤੋਂ ਬਾਹਰ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਸਾਨੂੰ ਕਿਸੇ ਤੀਜੀ-ਧਿਰ ਦੇ ਸੌਫਟਵੇਅਰ ਜਾਂ ਡਰਾਈਵਰਾਂ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਇੰਸਟਾਲੇਸ਼ਨ ਲਈ ਤਿਆਰੀ ਕਰ ਰਿਹਾ ਹੈ

ਸਿਸਟਮ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਸਾਨੂੰ ਉਬੰਟੂ ਡੈਸਕਟਾਪ ਚਿੱਤਰ ਦੀ ਲੋੜ ਹੈ। ਸਰਵਰ ਸਿਸਟਮ ਵਿੱਚ ਇੱਕ ਕਿਸਮ ਦਾ ਜੋਰਦਾਰ ਇੰਸਟਾਲਰ ਹੈ, ਜੋ ਬਹੁਤ ਜ਼ਿਆਦਾ ਸੁਤੰਤਰਤਾ ਦਿਖਾਉਂਦਾ ਹੈ ਜੋ ਕਿ UEFI ਸਿਸਟਮ ਭਾਗ ਨੂੰ ਇੱਕ ਡਿਸਕ ਉੱਤੇ ਹਿਲਾ ਕੇ, ਸਾਰੀ ਸੁੰਦਰਤਾ ਨੂੰ ਵਿਗਾੜ ਕੇ ਅਯੋਗ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਅਨੁਸਾਰ, ਇਹ ਸਿਰਫ UEFI ਮੋਡ ਵਿੱਚ ਸਥਾਪਿਤ ਹੈ। ਕੋਈ ਵਿਕਲਪ ਪੇਸ਼ ਨਹੀਂ ਕਰਦਾ।

ਅਸੀਂ ਇਸ ਤੋਂ ਖੁਸ਼ ਨਹੀਂ ਹਾਂ।

ਕਿਉਂ?ਬਦਕਿਸਮਤੀ ਨਾਲ, UEFI ਬੂਟ ਬੂਟ ਸੌਫਟਵੇਅਰ ਰੇਡ ਨਾਲ ਬਹੁਤ ਮਾੜਾ ਅਨੁਕੂਲ ਹੈ, ਕਿਉਂਕਿ... ਕੋਈ ਵੀ ਸਾਨੂੰ UEFI ESP ਭਾਗ ਲਈ ਰਿਜ਼ਰਵੇਸ਼ਨ ਦੀ ਪੇਸ਼ਕਸ਼ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਔਨਲਾਈਨ ਪਕਵਾਨਾ ਹਨ ਜੋ ਇੱਕ USB ਪੋਰਟ ਵਿੱਚ ਇੱਕ ਫਲੈਸ਼ ਡਰਾਈਵ ਤੇ ESP ਭਾਗ ਰੱਖਣ ਦਾ ਸੁਝਾਅ ਦਿੰਦੇ ਹਨ, ਪਰ ਇਹ ਅਸਫਲਤਾ ਦਾ ਇੱਕ ਬਿੰਦੂ ਹੈ. ਮੈਟਾਡੇਟਾ ਸੰਸਕਰਣ 1 ਦੇ ਨਾਲ ਸਾਫਟਵੇਅਰ mdadm RAID 0.9 ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੀਆਂ ਪਕਵਾਨਾਂ ਹਨ ਜੋ UEFI BIOS ਨੂੰ ਇਸ ਭਾਗ ਨੂੰ ਦੇਖਣ ਤੋਂ ਨਹੀਂ ਰੋਕਦੀਆਂ, ਪਰ ਇਹ ਖੁਸ਼ੀ ਦੇ ਪਲ ਤੱਕ ਰਹਿੰਦੀ ਹੈ ਜਦੋਂ BIOS ਜਾਂ ਕੋਈ ਹੋਰ ਹਾਰਡਵੇਅਰ OS ESP ਨੂੰ ਕੁਝ ਲਿਖਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਦੂਜੇ ਨਾਲ ਸਮਕਾਲੀ ਕਰਨਾ ਭੁੱਲ ਜਾਂਦਾ ਹੈ। ਸ਼ੀਸ਼ੇ

ਇਸ ਤੋਂ ਇਲਾਵਾ, UEFI ਬੂਟ NVRAM 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਡਿਸਕਾਂ ਦੇ ਨਾਲ ਨਵੇਂ ਸਿਸਟਮ ਵਿੱਚ ਨਹੀਂ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਮਦਰਬੋਰਡ ਦਾ ਹਿੱਸਾ ਹੈ।

ਇਸ ਲਈ, ਅਸੀਂ ਇੱਕ ਨਵੇਂ ਪਹੀਏ ਨੂੰ ਦੁਬਾਰਾ ਨਹੀਂ ਬਣਾਵਾਂਗੇ। ਸਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਤਿਆਰ-ਕੀਤੀ, ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਟੈਸਟ ਕੀਤੇ ਦਾਦਾ ਦੀ ਬਾਈਕ ਹੈ, ਜਿਸ ਨੂੰ ਹੁਣ ਲੀਗੇਸੀ/BIOS ਬੂਟ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, UEFI-ਅਨੁਕੂਲ ਸਿਸਟਮਾਂ 'ਤੇ CSM ਦਾ ਮਾਣ ਵਾਲਾ ਨਾਮ ਹੈ। ਅਸੀਂ ਇਸਨੂੰ ਸ਼ੈਲਫ ਤੋਂ ਉਤਾਰ ਲਵਾਂਗੇ, ਇਸਨੂੰ ਲੁਬਰੀਕੇਟ ਕਰਾਂਗੇ, ਟਾਇਰਾਂ ਨੂੰ ਪੰਪ ਕਰਾਂਗੇ ਅਤੇ ਇਸਨੂੰ ਸਿੱਲ੍ਹੇ ਕੱਪੜੇ ਨਾਲ ਪੂੰਝਾਂਗੇ।

ਉਬੰਟੂ ਦਾ ਡੈਸਕਟੌਪ ਸੰਸਕਰਣ ਵੀ ਲੀਗੇਸੀ ਬੂਟਲੋਡਰ ਨਾਲ ਸਹੀ ਤਰ੍ਹਾਂ ਸਥਾਪਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਇੱਥੇ, ਜਿਵੇਂ ਕਿ ਉਹ ਕਹਿੰਦੇ ਹਨ, ਘੱਟੋ ਘੱਟ ਵਿਕਲਪ ਹਨ.

ਅਤੇ ਇਸ ਲਈ, ਅਸੀਂ ਹਾਰਡਵੇਅਰ ਨੂੰ ਇਕੱਠਾ ਕਰਦੇ ਹਾਂ ਅਤੇ ਸਿਸਟਮ ਨੂੰ ਉਬੰਟੂ ਲਾਈਵ ਬੂਟ ਹੋਣ ਯੋਗ ਫਲੈਸ਼ ਡਰਾਈਵ ਤੋਂ ਲੋਡ ਕਰਦੇ ਹਾਂ। ਸਾਨੂੰ ਪੈਕੇਜਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਪਵੇਗੀ, ਇਸ ਲਈ ਅਸੀਂ ਤੁਹਾਡੇ ਲਈ ਕੰਮ ਕਰਨ ਵਾਲੇ ਨੈੱਟਵਰਕ ਨੂੰ ਸੈੱਟਅੱਪ ਕਰਾਂਗੇ। ਜੇਕਰ ਇਹ ਕੰਮ ਨਹੀਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਲੋੜੀਂਦੇ ਪੈਕੇਜਾਂ ਨੂੰ ਫਲੈਸ਼ ਡਰਾਈਵ ਉੱਤੇ ਪਹਿਲਾਂ ਹੀ ਲੋਡ ਕਰ ਸਕਦੇ ਹੋ।

ਅਸੀਂ ਡੈਸਕਟੌਪ ਵਾਤਾਵਰਣ ਵਿੱਚ ਜਾਂਦੇ ਹਾਂ, ਟਰਮੀਨਲ ਇਮੂਲੇਟਰ ਲਾਂਚ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਅਸੀਂ ਜਾਂਦੇ ਹਾਂ:

#sudo bash

ਕਿਵੇਂ…?ਉਪਰੋਕਤ ਲਾਈਨ ਸੂਡੋ ਬਾਰੇ ਹੋਲੀਵਾਰਾਂ ਲਈ ਕੈਨੋਨੀਕਲ ਟਰਿੱਗਰ ਹੈ। ਸੀ ਬੀоਵਧੇਰੇ ਮੌਕੇ ਆਉਂਦੇ ਹਨ ਅਤੇоਵੱਧ ਜ਼ਿੰਮੇਵਾਰੀ. ਸਵਾਲ ਇਹ ਹੈ ਕਿ ਕੀ ਤੁਸੀਂ ਇਸਨੂੰ ਆਪਣੇ ਆਪ 'ਤੇ ਲੈ ਸਕਦੇ ਹੋ. ਬਹੁਤ ਸਾਰੇ ਲੋਕ ਸੋਚਦੇ ਹਨ ਕਿ ਇਸ ਤਰੀਕੇ ਨਾਲ ਸੂਡੋ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਘੱਟੋ ਘੱਟ ਸਾਵਧਾਨ ਨਹੀਂ ਹੈ. ਹਾਲਾਂਕਿ:

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

ZFS ਕਿਉਂ ਨਹੀਂ...?ਜਦੋਂ ਅਸੀਂ ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ ਸੌਫਟਵੇਅਰ ਸਥਾਪਤ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਆਪਣੇ ਹਾਰਡਵੇਅਰ ਨੂੰ ਇਸ ਸੌਫਟਵੇਅਰ ਦੇ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਉਧਾਰ ਦਿੰਦੇ ਹਾਂ।
ਜਦੋਂ ਅਸੀਂ ਆਪਣੇ ਡੇਟਾ ਦੀ ਸੁਰੱਖਿਆ ਦੇ ਨਾਲ ਇਸ ਸੌਫਟਵੇਅਰ 'ਤੇ ਭਰੋਸਾ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਇਸ ਡੇਟਾ ਨੂੰ ਰੀਸਟੋਰ ਕਰਨ ਦੀ ਲਾਗਤ ਦੇ ਬਰਾਬਰ ਕਰਜ਼ਾ ਲੈਂਦੇ ਹਾਂ, ਜਿਸਦਾ ਸਾਨੂੰ ਕਿਸੇ ਦਿਨ ਭੁਗਤਾਨ ਕਰਨਾ ਪਵੇਗਾ।

ਇਸ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ZFS ਇੱਕ ਫੇਰਾਰੀ ਹੈ, ਅਤੇ mdadm+lvm ਇੱਕ ਸਾਈਕਲ ਵਰਗਾ ਹੈ।

ਵਿਸ਼ਾ-ਵਸਤੂ, ਲੇਖਕ ਫੇਰਾਰੀ ਦੀ ਬਜਾਏ ਅਣਜਾਣ ਵਿਅਕਤੀਆਂ ਨੂੰ ਕ੍ਰੈਡਿਟ 'ਤੇ ਸਾਈਕਲ ਦੇਣ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ। ਉੱਥੇ, ਮੁੱਦੇ ਦੀ ਕੀਮਤ ਜ਼ਿਆਦਾ ਨਹੀਂ ਹੈ. ਅਧਿਕਾਰਾਂ ਦੀ ਲੋੜ ਨਹੀਂ। ਟ੍ਰੈਫਿਕ ਨਿਯਮਾਂ ਨਾਲੋਂ ਸਰਲ। ਪਾਰਕਿੰਗ ਮੁਫ਼ਤ ਹੈ। ਕਰਾਸ-ਕੰਟਰੀ ਸਮਰੱਥਾ ਬਿਹਤਰ ਹੈ। ਤੁਸੀਂ ਹਮੇਸ਼ਾਂ ਸਾਈਕਲ ਨਾਲ ਲੱਤਾਂ ਜੋੜ ਸਕਦੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਆਪਣੇ ਹੱਥਾਂ ਨਾਲ ਸਾਈਕਲ ਦੀ ਮੁਰੰਮਤ ਕਰ ਸਕਦੇ ਹੋ.

ਫਿਰ BTRFS ਕਿਉਂ...?ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੂੰ ਬੂਟ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇੱਕ ਫਾਈਲ ਸਿਸਟਮ ਦੀ ਲੋੜ ਹੈ ਜੋ ਲੀਗੇਸੀ/BIOS GRUB ਵਿੱਚ ਸਮਰਥਿਤ ਹੈ, ਅਤੇ ਉਸੇ ਸਮੇਂ ਲਾਈਵ ਸਨੈਪਸ਼ਾਟ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਅਸੀਂ ਇਸਨੂੰ /boot ਭਾਗ ਲਈ ਵਰਤਾਂਗੇ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਲੇਖਕ ਇਸ FS ਨੂੰ / (ਰੂਟ) ਲਈ ਵਰਤਣਾ ਪਸੰਦ ਕਰਦਾ ਹੈ, ਇਹ ਨੋਟ ਕਰਨਾ ਨਾ ਭੁੱਲੋ ਕਿ ਕਿਸੇ ਹੋਰ ਸਾਫਟਵੇਅਰ ਲਈ ਤੁਸੀਂ LVM ਉੱਤੇ ਵੱਖਰੇ ਭਾਗ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਲੋੜੀਂਦੀਆਂ ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਮਾਊਂਟ ਕਰ ਸਕਦੇ ਹੋ।

ਅਸੀਂ ਇਸ FS 'ਤੇ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਜਾਂ ਡਾਟਾਬੇਸ ਦੀਆਂ ਕੋਈ ਤਸਵੀਰਾਂ ਸਟੋਰ ਨਹੀਂ ਕਰਾਂਗੇ।
ਇਸ FS ਦੀ ਵਰਤੋਂ ਸਿਸਟਮ ਨੂੰ ਬੰਦ ਕੀਤੇ ਬਿਨਾਂ ਸਨੈਪਸ਼ਾਟ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਵੇਗੀ ਅਤੇ ਫਿਰ ਇਹਨਾਂ ਸਨੈਪਸ਼ਾਟਾਂ ਨੂੰ ਭੇਜੋ/ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬੈਕਅੱਪ ਡਿਸਕ 'ਤੇ ਟ੍ਰਾਂਸਫ਼ਰ ਕੀਤਾ ਜਾਵੇਗਾ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਲੇਖਕ ਆਮ ਤੌਰ 'ਤੇ ਹਾਰਡਵੇਅਰ 'ਤੇ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਘੱਟੋ-ਘੱਟ ਸੌਫਟਵੇਅਰ ਰੱਖਣ ਅਤੇ ਹੋਰ ਸਾਰੇ ਸੌਫਟਵੇਅਰਾਂ ਨੂੰ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਵਿੱਚ ਚਲਾਉਣਾ ਪਸੰਦ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ GPUs ਅਤੇ PCI-USB ਹੋਸਟ ਕੰਟਰੋਲਰਾਂ ਨੂੰ IOMMU ਰਾਹੀਂ KVM ਨੂੰ ਅੱਗੇ ਭੇਜਣਾ।

ਹਾਰਡਵੇਅਰ 'ਤੇ ਬਚੀਆਂ ਚੀਜ਼ਾਂ ਹਨ ਡਾਟਾ ਸਟੋਰੇਜ, ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਅਤੇ ਬੈਕਅੱਪ।

ਜੇ ਤੁਸੀਂ 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


ਡਿਸਕ ਲੇਆਉਟ

NVMe SSD

ਪਰ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਚਿੰਨ੍ਹਿਤ ਨਹੀਂ ਕਰਾਂਗੇ। ਸਭ ਇੱਕੋ ਜਿਹਾ, ਸਾਡਾ BIOS ਇਹਨਾਂ ਡਰਾਈਵਾਂ ਨੂੰ ਨਹੀਂ ਦੇਖਦਾ. ਇਸ ਲਈ, ਉਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਾਫਟਵੇਅਰ ਰੇਡ 'ਤੇ ਜਾਣਗੇ। ਅਸੀਂ ਉੱਥੇ ਸੈਕਸ਼ਨ ਵੀ ਨਹੀਂ ਬਣਾਵਾਂਗੇ। ਜੇ ਤੁਸੀਂ "ਕੈਨਨ" ਜਾਂ "ਮੁੱਖ ਤੌਰ 'ਤੇ" ਦੀ ਪਾਲਣਾ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਵੱਡਾ ਭਾਗ ਬਣਾਓ, ਜਿਵੇਂ ਕਿ ਇੱਕ HDD।

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 ਟੀਬੀ ਹੈ। ਇਹ MBR ਲਈ ਸਵੀਕਾਰਯੋਗ ਸੀਮਾ ਦੇ ਅੰਦਰ ਹੈ, ਜਿਸਦੀ ਅਸੀਂ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਜੇ ਜਰੂਰੀ ਹੋਵੇ, GPT ਨਾਲ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ. GPT ਡਿਸਕਾਂ ਦੀ ਇੱਕ ਅਨੁਕੂਲਤਾ ਪਰਤ ਹੁੰਦੀ ਹੈ ਜੋ MBR-ਅਨੁਕੂਲ ਸਿਸਟਮਾਂ ਨੂੰ ਪਹਿਲੇ 4 ਭਾਗਾਂ ਨੂੰ ਦੇਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ ਜੇਕਰ ਉਹ ਪਹਿਲੇ 2 ਟੈਰਾਬਾਈਟ ਦੇ ਅੰਦਰ ਸਥਿਤ ਹਨ। ਮੁੱਖ ਗੱਲ ਇਹ ਹੈ ਕਿ ਇਹਨਾਂ ਡਿਸਕਾਂ ਉੱਤੇ ਬੂਟ ਭਾਗ ਅਤੇ bios_grub ਭਾਗ ਸ਼ੁਰੂ ਵਿੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ GPT Legacy/BIOS ਡਰਾਈਵਾਂ ਤੋਂ ਬੂਟ ਕਰਨ ਦੀ ਵੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਪਰ ਇਹ ਸਾਡਾ ਮਾਮਲਾ ਨਹੀਂ ਹੈ।

ਇੱਥੇ ਅਸੀਂ ਦੋ ਭਾਗ ਬਣਾਵਾਂਗੇ। ਪਹਿਲੇ ਦਾ ਆਕਾਰ 1 GB ਹੋਵੇਗਾ ਅਤੇ RAID 1 /boot ਲਈ ਵਰਤਿਆ ਜਾਵੇਗਾ।

ਦੂਸਰਾ RAID 6 ਲਈ ਵਰਤਿਆ ਜਾਵੇਗਾ ਅਤੇ ਡਰਾਈਵ ਦੇ ਅੰਤ ਵਿੱਚ ਇੱਕ ਛੋਟੇ ਅਣ-ਅਲਾਟ ਕੀਤੇ ਖੇਤਰ ਨੂੰ ਛੱਡ ਕੇ ਬਾਕੀ ਬਚੀ ਸਾਰੀ ਖਾਲੀ ਥਾਂ ਲੈ ਲਵੇਗਾ।

ਇਹ ਅਣ-ਨਿਸ਼ਾਨਿਤ ਖੇਤਰ ਕੀ ਹੈ?ਨੈੱਟਵਰਕ 'ਤੇ ਸਰੋਤਾਂ ਦੇ ਅਨੁਸਾਰ, ਸਾਡੇ SATA SSDs ਵਿੱਚ 6 ਤੋਂ 78 ਗੀਗਾਬਾਈਟ ਦੇ ਆਕਾਰ ਵਿੱਚ ਇੱਕ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਵਿਸਤਾਰਯੋਗ SLC ਕੈਸ਼ ਹੈ। ਡਰਾਈਵ ਦੀ ਡੇਟਾ ਸ਼ੀਟ ਵਿੱਚ "ਗੀਗਾਬਾਈਟ" ਅਤੇ "ਗੀਬੀਬਾਈਟਸ" ਵਿੱਚ ਅੰਤਰ ਦੇ ਕਾਰਨ ਸਾਨੂੰ 6 ਗੀਗਾਬਾਈਟ "ਮੁਫ਼ਤ ਵਿੱਚ" ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹਨ। ਬਾਕੀ 72 ਗੀਗਾਬਾਈਟ ਅਣਵਰਤੀ ਥਾਂ ਤੋਂ ਅਲਾਟ ਕੀਤੇ ਗਏ ਹਨ।

ਇੱਥੇ ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ SLC ਕੈਸ਼ ਹੈ, ਅਤੇ ਸਪੇਸ 4 ਬਿੱਟ 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


NVMe SSD

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

ਕਿਉਂ -ਸਮਝੋ -ਸਾਫ਼...?ਐਰੇ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਬਚਣ ਲਈ। RAID ਪੱਧਰ 1 ਅਤੇ 6 ਦੋਵਾਂ ਲਈ ਇਹ ਵੈਧ ਹੈ। ਹਰ ਚੀਜ਼ ਬਿਨਾਂ ਸ਼ੁਰੂਆਤੀ ਕੰਮ ਕਰ ਸਕਦੀ ਹੈ ਜੇਕਰ ਇਹ ਇੱਕ ਨਵੀਂ ਐਰੇ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਿਰਜਣ 'ਤੇ SSD ਐਰੇ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨਾ TBW ਸਰੋਤ ਦੀ ਬਰਬਾਦੀ ਹੈ। ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ "ਸ਼ੁਰੂ" ਕਰਨ ਲਈ ਅਸੈਂਬਲ ਕੀਤੇ SSD ਐਰੇ 'ਤੇ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ TRIM/DISCARD ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।

SSD ਐਰੇ ਲਈ, RAID 1 ਡਿਸਕਾਰਡ ਬਾਕਸ ਦੇ ਬਾਹਰ ਸਮਰਥਿਤ ਹੈ।

SSD RAID 6 ਡਿਸਕਾਰਡ ਐਰੇ ਲਈ, ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਕਰਨਲ ਮੋਡੀਊਲ ਪੈਰਾਮੀਟਰਾਂ ਵਿੱਚ ਯੋਗ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

ਇਹ ਕੇਵਲ ਤਾਂ ਹੀ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜੇਕਰ ਇਸ ਸਿਸਟਮ ਵਿੱਚ ਲੈਵਲ 4/5/6 ਐਰੇ ਵਿੱਚ ਵਰਤੇ ਗਏ ਸਾਰੇ SSDs ਵਿੱਚ discard_zeroes_data ਲਈ ਕਾਰਜਸ਼ੀਲ ਸਮਰਥਨ ਹੈ। ਕਈ ਵਾਰ ਤੁਹਾਨੂੰ ਅਜੀਬ ਡਰਾਈਵਾਂ ਮਿਲਦੀਆਂ ਹਨ ਜੋ ਕਰਨਲ ਨੂੰ ਦੱਸਦੀਆਂ ਹਨ ਕਿ ਇਹ ਫੰਕਸ਼ਨ ਸਮਰਥਿਤ ਹੈ, ਪਰ ਅਸਲ ਵਿੱਚ ਇਹ ਉੱਥੇ ਨਹੀਂ ਹੈ, ਜਾਂ ਫੰਕਸ਼ਨ ਹਮੇਸ਼ਾ ਕੰਮ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਇਸ ਸਮੇਂ, ਸਮਰਥਨ ਲਗਭਗ ਹਰ ਜਗ੍ਹਾ ਉਪਲਬਧ ਹੈ, ਹਾਲਾਂਕਿ, ਪੁਰਾਣੀਆਂ ਡਰਾਈਵਾਂ ਅਤੇ ਫਰਮਵੇਅਰ ਗਲਤੀਆਂ ਦੇ ਨਾਲ ਹਨ. ਇਸ ਕਾਰਨ ਕਰਕੇ, 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 ਨੂੰ ਸੰਖੇਪ ਕੀਤਾ ਗਿਆ ਹੈ। ਅੰਕੜਿਆਂ ਦੇ ਅਨੁਸਾਰ, IO ਦਾ 99% 512K ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ.

RAID 6 IOPS ਪ੍ਰਤੀ ਲਿਖਤ ਹਮੇਸ਼ਾ ਇੱਕ ਡਰਾਈਵ ਦੇ IOPS ਤੋਂ ਘੱਟ ਜਾਂ ਬਰਾਬਰ। ਜਦੋਂ, ਇੱਕ ਬੇਤਰਤੀਬ ਰੀਡ ਦੇ ਤੌਰ ਤੇ, IOPS ਇੱਕ ਡਰਾਈਵ ਨਾਲੋਂ ਕਈ ਗੁਣਾ ਵੱਡਾ ਹੋ ਸਕਦਾ ਹੈ, ਅਤੇ ਇੱਥੇ ਬਲਾਕ ਦਾ ਆਕਾਰ ਮੁੱਖ ਮਹੱਤਵ ਰੱਖਦਾ ਹੈ।
ਲੇਖਕ ਇੱਕ ਪੈਰਾਮੀਟਰ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਵਿੱਚ ਬਿੰਦੂ ਨਹੀਂ ਦੇਖਦਾ ਜੋ RAID 6 ਦੁਆਰਾ-ਡਿਜ਼ਾਇਨ ਵਿੱਚ ਖਰਾਬ ਹੈ ਅਤੇ ਇਸ ਦੀ ਬਜਾਏ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ ਕਿ RAID 6 ਕਿਸ ਵਿੱਚ ਚੰਗਾ ਹੈ।
ਅਸੀਂ ਇੱਕ NVMe ਕੈਸ਼ ਅਤੇ ਪਤਲੇ-ਪ੍ਰੋਵਿਜ਼ਨਿੰਗ ਟ੍ਰਿਕਸ ਨਾਲ RAID 6 ਦੇ ਖਰਾਬ ਬੇਤਰਤੀਬੇ ਲਿਖਣ ਲਈ ਮੁਆਵਜ਼ਾ ਦੇਵਾਂਗੇ।

ਅਸੀਂ ਅਜੇ ਤੱਕ RAID 6 ਲਈ ਡਿਸਕਾਰਡ ਨੂੰ ਸਮਰੱਥ ਨਹੀਂ ਕੀਤਾ ਹੈ। ਇਸਲਈ ਅਸੀਂ ਇਸ ਐਰੇ ਨੂੰ ਫਿਲਹਾਲ "ਸ਼ੁਰੂ" ਨਹੀਂ ਕਰਾਂਗੇ। ਅਸੀਂ ਇਸਨੂੰ ਬਾਅਦ ਵਿੱਚ, OS ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕਰਾਂਗੇ।

SATA HDD

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

NVMe RAID ਉੱਤੇ LVM

ਸਪੀਡ ਲਈ, ਅਸੀਂ ਰੂਟ ਫਾਈਲ ਸਿਸਟਮ ਨੂੰ NVMe RAID 1 ਉੱਤੇ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਜੋ ਕਿ /dev/md0 ਹੈ।
ਹਾਲਾਂਕਿ, ਸਾਨੂੰ ਅਜੇ ਵੀ ਹੋਰ ਲੋੜਾਂ ਲਈ ਇਸ ਤੇਜ਼ ਐਰੇ ਦੀ ਲੋੜ ਪਵੇਗੀ, ਜਿਵੇਂ ਕਿ ਸਵੈਪ, ਮੈਟਾਡੇਟਾ ਅਤੇ LVM-ਕੈਸ਼ ਅਤੇ LVM-ਪਤਲਾ ਮੈਟਾਡੇਟਾ, ਇਸ ਲਈ ਅਸੀਂ ਇਸ ਐਰੇ 'ਤੇ ਇੱਕ LVM VG ਬਣਾਵਾਂਗੇ।

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

ਆਉ ਰੂਟ ਫਾਇਲ ਸਿਸਟਮ ਲਈ ਇੱਕ ਭਾਗ ਬਣਾਈਏ।

#lvcreate -L 128G --name root root

ਆਉ ਰੈਮ ਦੇ ਆਕਾਰ ਦੇ ਅਨੁਸਾਰ ਸਵੈਪ ਕਰਨ ਲਈ ਇੱਕ ਭਾਗ ਬਣਾਉਂਦੇ ਹਾਂ।

#lvcreate -L 32G --name swap root

OS ਸਥਾਪਨਾ

ਕੁੱਲ ਮਿਲਾ ਕੇ, ਸਾਡੇ ਕੋਲ ਸਿਸਟਮ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਸਭ ਕੁਝ ਜ਼ਰੂਰੀ ਹੈ.

ਉਬੰਟੂ ਲਾਈਵ ਵਾਤਾਵਰਨ ਤੋਂ ਸਿਸਟਮ ਇੰਸਟਾਲੇਸ਼ਨ ਵਿਜ਼ਾਰਡ ਲਾਂਚ ਕਰੋ। ਸਧਾਰਨ ਇੰਸਟਾਲੇਸ਼ਨ. ਸਿਰਫ਼ ਇੰਸਟਾਲੇਸ਼ਨ ਲਈ ਡਿਸਕਾਂ ਦੀ ਚੋਣ ਕਰਨ ਦੇ ਪੜਾਅ 'ਤੇ, ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖਿਆਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

• /dev/md1, - ਮਾਊਂਟ ਪੁਆਇੰਟ /boot, FS - BTRFS
• /dev/root/root (aka /dev/mapper/root-root), - ਮਾਊਂਟ ਪੁਆਇੰਟ / (ਰੂਟ), FS - BTRFS
• /dev/root/swap (ਉਰਫ਼ /dev/mapper/root-swap), - ਸਵੈਪ ਭਾਗ ਵਜੋਂ ਵਰਤੋਂ
• ਬੂਟਲੋਡਰ ਨੂੰ /dev/sda ਉੱਤੇ ਇੰਸਟਾਲ ਕਰੋ

ਜਦੋਂ ਤੁਸੀਂ BTRFS ਨੂੰ ਰੂਟ ਫਾਈਲ ਸਿਸਟਮ ਵਜੋਂ ਚੁਣਦੇ ਹੋ, ਤਾਂ ਇੰਸਟਾਲਰ ਆਪਣੇ ਆਪ ਹੀ / (ਰੂਟ) ਲਈ "@" ਨਾਮਕ ਦੋ BTRFS ਵਾਲੀਅਮ ਬਣਾ ਦੇਵੇਗਾ, ਅਤੇ /home ਲਈ "@home"।

ਚਲੋ ਇੰਸਟਾਲੇਸ਼ਨ ਸ਼ੁਰੂ ਕਰੀਏ...

ਇੰਸਟਾਲੇਸ਼ਨ ਇੱਕ ਮਾਡਲ ਡਾਇਲਾਗ ਬਾਕਸ ਦੇ ਨਾਲ ਖਤਮ ਹੋਵੇਗੀ ਜੋ ਬੂਟਲੋਡਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਵਿੱਚ ਇੱਕ ਤਰੁੱਟੀ ਦਰਸਾਉਂਦੀ ਹੈ। ਬਦਕਿਸਮਤੀ ਨਾਲ, ਤੁਸੀਂ ਮਿਆਰੀ ਸਾਧਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਡਾਇਲਾਗ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਅਤੇ ਸਥਾਪਨਾ ਨੂੰ ਜਾਰੀ ਰੱਖਣ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੋਗੇ। ਅਸੀਂ ਸਿਸਟਮ ਤੋਂ ਲੌਗ ਆਉਟ ਕਰਦੇ ਹਾਂ ਅਤੇ ਦੁਬਾਰਾ ਲੌਗ ਇਨ ਕਰਦੇ ਹਾਂ, ਇੱਕ ਸਾਫ਼ ਉਬੰਟੂ ਲਾਈਵ ਡੈਸਕਟਾਪ ਵਿੱਚ ਸਮਾਪਤ ਹੁੰਦਾ ਹੈ। ਟਰਮੀਨਲ ਖੋਲ੍ਹੋ, ਅਤੇ ਦੁਬਾਰਾ:

#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 ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ

ਆਉ ਟ੍ਰਿਮ/ਡਿਸਕਾਰਡ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ ਰੇਡ 6 ਮੋਡੀਊਲ ਲਈ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰੀਏ:

#cat >/etc/modprobe.d/raid456.conf << EOF
options raid456 devices_handle_discard_safely=1
EOF

ਆਉ ਆਪਣੇ ਐਰੇ ਨੂੰ ਥੋੜਾ ਬਦਲੀਏ:

#cat >/etc/udev/rules.d/60-md.rules << EOF
SUBSYSTEM=="block", KERNEL=="md*", ACTION=="change", TEST=="md/stripe_cache_size", ATTR{md/stripe_cache_size}="32768"
SUBSYSTEM=="block", KERNEL=="md*", ACTION=="change", TEST=="md/sync_speed_min", ATTR{md/sync_speed_min}="48000"
SUBSYSTEM=="block", KERNEL=="md*", ACTION=="change", TEST=="md/sync_speed_max", ATTR{md/sync_speed_max}="300000"
EOF
#cat >/etc/udev/rules.d/62-hdparm.rules << EOF
SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="1", RUN+="/sbin/hdparm -B 254 /dev/%k"
EOF
#cat >/etc/udev/rules.d/63-blockdev.rules << EOF
SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="1", RUN+="/sbin/blockdev --setra 1024 /dev/%k"
SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="md*", RUN+="/sbin/blockdev --setra 0 /dev/%k"
EOF

ਇਹ ਕੀ ਸੀ..?ਅਸੀਂ udev ਨਿਯਮਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਬਣਾਇਆ ਹੈ ਜੋ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਕਰੇਗਾ:

• RAID 2020 ਲਈ ਬਲਾਕ ਕੈਸ਼ ਦਾ ਆਕਾਰ 6 ਲਈ ਢੁਕਵਾਂ ਹੋਣ ਲਈ ਸੈੱਟ ਕਰੋ। ਡਿਫੌਲਟ ਮੁੱਲ, ਅਜਿਹਾ ਲੱਗਦਾ ਹੈ, Linux ਦੇ ਬਣਨ ਤੋਂ ਬਾਅਦ ਬਦਲਿਆ ਨਹੀਂ ਹੈ, ਅਤੇ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਢੁਕਵਾਂ ਨਹੀਂ ਹੈ।
• ਐਰੇ ਜਾਂਚਾਂ/ਸਮਕਾਲੀਕਰਨ ਦੀ ਮਿਆਦ ਲਈ ਘੱਟੋ-ਘੱਟ IO ਰਿਜ਼ਰਵ ਕਰੋ। ਇਹ ਤੁਹਾਡੇ ਐਰੇ ਨੂੰ ਲੋਡ ਅਧੀਨ ਸਦੀਵੀ ਸਮਕਾਲੀ ਸਥਿਤੀ ਵਿੱਚ ਫਸਣ ਤੋਂ ਰੋਕਣ ਲਈ ਹੈ।
• ਐਰੇ ਦੀ ਜਾਂਚ/ਸਮਕਾਲੀਕਰਨ ਦੌਰਾਨ ਅਧਿਕਤਮ IO ਨੂੰ ਸੀਮਿਤ ਕਰੋ। ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਤਾਂ ਕਿ SSD RAIDs ਨੂੰ ਸਮਕਾਲੀਕਰਨ/ਚੈੱਕ ਕਰਨ ਨਾਲ ਤੁਹਾਡੀਆਂ ਡਰਾਈਵਾਂ ਨੂੰ ਕਰਿਸਪ ਨਾ ਬਣਾਇਆ ਜਾ ਸਕੇ। ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ NVMe ਲਈ ਸੱਚ ਹੈ। (ਰੇਡੀਏਟਰ ਬਾਰੇ ਯਾਦ ਰੱਖੋ? ਮੈਂ ਮਜ਼ਾਕ ਨਹੀਂ ਕਰ ਰਿਹਾ ਸੀ।)
• ਡਿਸਕਾਂ ਨੂੰ ਸਪਿੰਡਲ ਰੋਟੇਸ਼ਨ (HDD) ਨੂੰ APM ਰਾਹੀਂ ਰੋਕਣ ਤੋਂ ਰੋਕੋ ਅਤੇ ਡਿਸਕ ਕੰਟਰੋਲਰਾਂ ਲਈ ਸਲੀਪ ਟਾਈਮਆਊਟ ਨੂੰ 7 ਘੰਟੇ ਤੱਕ ਸੈੱਟ ਕਰੋ। ਤੁਸੀਂ APM ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਯੋਗ ਕਰ ਸਕਦੇ ਹੋ ਜੇਕਰ ਤੁਹਾਡੀਆਂ ਡਰਾਈਵਾਂ ਇਹ ਕਰ ਸਕਦੀਆਂ ਹਨ (-B 255)। ਡਿਫੌਲਟ ਮੁੱਲ ਦੇ ਨਾਲ, ਡਰਾਈਵਾਂ ਪੰਜ ਸਕਿੰਟਾਂ ਬਾਅਦ ਬੰਦ ਹੋ ਜਾਣਗੀਆਂ। ਫਿਰ OS ਡਿਸਕ ਕੈਸ਼ ਨੂੰ ਰੀਸੈਟ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ, ਡਿਸਕਾਂ ਦੁਬਾਰਾ ਸਪਿਨ ਹੋ ਜਾਣਗੀਆਂ, ਅਤੇ ਸਭ ਕੁਝ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਹੋ ਜਾਵੇਗਾ। ਡਿਸਕਾਂ ਵਿੱਚ ਸਪਿੰਡਲ ਰੋਟੇਸ਼ਨਾਂ ਦੀ ਸੀਮਤ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਹੁੰਦੀ ਹੈ। ਅਜਿਹਾ ਸਧਾਰਨ ਡਿਫੌਲਟ ਚੱਕਰ ਕੁਝ ਸਾਲਾਂ ਵਿੱਚ ਤੁਹਾਡੀਆਂ ਡਿਸਕਾਂ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਮਾਰ ਸਕਦਾ ਹੈ। ਸਾਰੀਆਂ ਡਿਸਕਾਂ ਇਸ ਤੋਂ ਪੀੜਤ ਨਹੀਂ ਹਨ, ਪਰ ਸਾਡੀਆਂ "ਲੈਪਟਾਪ" ਹਨ, ਢੁਕਵੀਂ ਡਿਫੌਲਟ ਸੈਟਿੰਗਾਂ ਦੇ ਨਾਲ, ਜੋ ਕਿ ਰੇਡ ਨੂੰ ਇੱਕ ਮਿੰਨੀ-MAID ਵਰਗਾ ਬਣਾਉਂਦੀਆਂ ਹਨ।
• ਡਿਸਕ (ਰੋਟੇਟਿੰਗ) 1 ਮੈਗਾਬਾਈਟ 'ਤੇ ਰੀਡਹੈੱਡ ਇੰਸਟਾਲ ਕਰੋ - ਲਗਾਤਾਰ ਦੋ ਬਲਾਕ/ਚੰਕ ਰੇਡ 6
• ਐਰੇ 'ਤੇ ਰੀਡਹੈੱਡ ਨੂੰ ਅਯੋਗ ਕਰੋ.

ਆਉ ਸੰਪਾਦਿਤ ਕਰੀਏ /etc/fstab:

#cat >/etc/fstab << EOF
# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
# file-system mount-point type options dump pass
/dev/mapper/root-root / btrfs defaults,space_cache,noatime,nodiratime,discard,subvol=@ 0 1
UUID=$(blkid -o value -s UUID /dev/md1) /boot btrfs defaults,space_cache,noatime,nodiratime,discard 0 2
/dev/mapper/root-root /home btrfs defaults,space_cache,noatime,nodiratime,discard,subvol=@home 0 2
/dev/mapper/root-swap none swap sw 0 0
EOF
ਅਜਿਹਾ ਕਿਉਂ ਹੈ..?ਅਸੀਂ UUID ਦੁਆਰਾ /boot ਭਾਗ ਦੀ ਖੋਜ ਕਰਾਂਗੇ। ਐਰੇ ਨਾਮਕਰਨ ਸਿਧਾਂਤਕ ਤੌਰ 'ਤੇ ਬਦਲ ਸਕਦਾ ਹੈ।

ਅਸੀਂ /dev/mapper/vg-lv ਸੰਕੇਤ ਵਿੱਚ LVM ਨਾਮਾਂ ਦੁਆਰਾ ਬਾਕੀ ਬਚੇ ਭਾਗਾਂ ਦੀ ਖੋਜ ਕਰਾਂਗੇ, ਕਿਉਂਕਿ ਉਹ ਭਾਗਾਂ ਨੂੰ ਬਿਲਕੁਲ ਵਿਲੱਖਣ ਢੰਗ ਨਾਲ ਪਛਾਣਦੇ ਹਨ।

ਅਸੀਂ LVM ਲਈ UUID ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੇ ਕਿਉਂਕਿ LVM ਵਾਲੀਅਮ ਦਾ UUID ਅਤੇ ਉਹਨਾਂ ਦੇ ਸਨੈਪਸ਼ਾਟ ਇੱਕੋ ਜਿਹੇ ਹੋ ਸਕਦੇ ਹਨ।ਮਾਊਂਟ /dev/mapper/root-root.. ਦੋ ਵਾਰ?ਹਾਂ। ਬਿਲਕੁਲ। BTRFS ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ। ਇਸ ਫਾਇਲ ਸਿਸਟਮ ਨੂੰ ਵੱਖ-ਵੱਖ ਸਬਵੋਲ ਨਾਲ ਕਈ ਵਾਰ ਮਾਊਂਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਇਸੇ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਕਾਰਨ, ਮੈਂ ਕਦੇ ਵੀ ਕਿਰਿਆਸ਼ੀਲ BTRFS ਵਾਲੀਅਮਾਂ ਦੇ LVM ਸਨੈਪਸ਼ਾਟ ਬਣਾਉਣ ਦੀ ਸਿਫਾਰਸ਼ ਨਹੀਂ ਕਰਦਾ ਹਾਂ। ਜਦੋਂ ਤੁਸੀਂ ਰੀਬੂਟ ਕਰਦੇ ਹੋ ਤਾਂ ਤੁਹਾਨੂੰ ਹੈਰਾਨੀ ਹੋ ਸਕਦੀ ਹੈ।

ਆਉ mdadm ਸੰਰਚਨਾ ਨੂੰ ਮੁੜ ਤਿਆਰ ਕਰੀਏ:

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

ਆਓ LVM ਸੈਟਿੰਗਾਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰੀਏ:

#cat >>/etc/lvm/lvmlocal.conf << EOF

activation {
thin_pool_autoextend_threshold=90
thin_pool_autoextend_percent=5
}
allocation {
cache_pool_max_chunks=2097152
}
devices {
global_filter=["r|^/dev/.*_corig$|","r|^/dev/.*_cdata$|","r|^/dev/.*_cmeta$|","r|^/dev/.*gpv$|","r|^/dev/images/.*$|","r|^/dev/mapper/images.*$|","r|^/dev/backup/.*$|","r|^/dev/mapper/backup.*$|"] issue_discards=1
}
EOF

ਇਹ ਕੀ ਸੀ..?ਅਸੀਂ ਵੌਲਯੂਮ ਦੇ 90% ਦੁਆਰਾ ਕਬਜ਼ੇ ਵਾਲੀ ਥਾਂ ਦੇ 5% ਤੱਕ ਪਹੁੰਚਣ 'ਤੇ LVM ਪਤਲੇ ਪੂਲ ਦੇ ਆਟੋਮੈਟਿਕ ਵਿਸਥਾਰ ਨੂੰ ਸਮਰੱਥ ਬਣਾਇਆ ਹੈ।

ਅਸੀਂ LVM ਕੈਸ਼ ਲਈ ਕੈਸ਼ ਬਲਾਕਾਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਵਧਾ ਦਿੱਤੀ ਹੈ।

ਅਸੀਂ LVM ਨੂੰ LVM ਵਾਲੀਅਮ (PV) ਦੀ ਖੋਜ ਕਰਨ ਤੋਂ ਰੋਕਿਆ ਹੈ:

• LVM ਕੈਸ਼ (cdata) ਵਾਲੇ ਯੰਤਰ
• LVM ਕੈਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੈਸ਼ ਕੀਤੇ ਜੰਤਰ, ਕੈਸ਼ ਨੂੰ ਛੱਡ ਕੇ ( _corig). ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਕੈਸ਼ ਕੀਤੀ ਡਿਵਾਈਸ ਨੂੰ ਅਜੇ ਵੀ ਕੈਸ਼ ਦੁਆਰਾ ਸਕੈਨ ਕੀਤਾ ਜਾਵੇਗਾ (ਸਿਰਫ਼ ).
• LVM ਕੈਸ਼ ਮੈਟਾਡੇਟਾ (cmeta) ਵਾਲੇ ਯੰਤਰ
• VG ਵਿੱਚ ਸਾਰੀਆਂ ਡਿਵਾਈਸਾਂ ਨਾਮ ਚਿੱਤਰਾਂ ਨਾਲ। ਇੱਥੇ ਸਾਡੇ ਕੋਲ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਦੇ ਡਿਸਕ ਪ੍ਰਤੀਬਿੰਬ ਹੋਣਗੇ, ਅਤੇ ਅਸੀਂ ਨਹੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਹੋਸਟ ਉੱਤੇ LVM ਗੈਸਟ OS ਨਾਲ ਸਬੰਧਤ ਵਾਲੀਅਮ ਨੂੰ ਸਰਗਰਮ ਕਰੇ।
• VG ਵਿੱਚ ਨਾਮ ਬੈਕਅੱਪ ਦੇ ਨਾਲ ਸਾਰੀਆਂ ਡਿਵਾਈਸਾਂ। ਇੱਥੇ ਸਾਡੇ ਕੋਲ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਚਿੱਤਰਾਂ ਦੀਆਂ ਬੈਕਅੱਪ ਕਾਪੀਆਂ ਹੋਣਗੀਆਂ।
• ਉਹ ਸਾਰੇ ਯੰਤਰ ਜਿਨ੍ਹਾਂ ਦਾ ਨਾਮ “gpv” (ਗੈਸਟ ਫਿਜ਼ੀਕਲ ਵਾਲੀਅਮ) ਨਾਲ ਖਤਮ ਹੁੰਦਾ ਹੈ।

ਅਸੀਂ LVM VG 'ਤੇ ਖਾਲੀ ਥਾਂ ਖਾਲੀ ਕਰਨ ਵੇਲੇ ਡਿਸਕਾਰਡ ਸਮਰਥਨ ਯੋਗ ਕੀਤਾ ਹੈ। ਧਿਆਨ ਰੱਖੋ. ਇਹ SSD 'ਤੇ LVs ਨੂੰ ਮਿਟਾਉਣ ਵਿੱਚ ਕਾਫ਼ੀ ਸਮਾਂ ਬਰਬਾਦ ਕਰੇਗਾ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ SSD RAID 6 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਯੋਜਨਾ ਦੇ ਅਨੁਸਾਰ, ਅਸੀਂ ਪਤਲੇ ਪ੍ਰਬੰਧ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਇਸ ਲਈ ਇਹ ਸਾਡੇ ਲਈ ਬਿਲਕੁਲ ਵੀ ਰੁਕਾਵਟ ਨਹੀਂ ਬਣੇਗਾ।

ਆਓ initramfs ਚਿੱਤਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰੀਏ:

#update-initramfs -u -k all

ਗਰਬ ਨੂੰ ਸਥਾਪਿਤ ਅਤੇ ਸੰਰਚਿਤ ਕਰੋ:

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

ਕਿਹੜੀਆਂ ਡਿਸਕਾਂ ਦੀ ਚੋਣ ਕਰਨੀ ਹੈ?ਉਹ ਸਾਰੇ ਜੋ sd* ਹਨ। ਸਿਸਟਮ ਨੂੰ ਕਿਸੇ ਵੀ ਕੰਮ ਕਰਨ ਵਾਲੀ SATA ਡਰਾਈਵ ਜਾਂ SSD ਤੋਂ ਬੂਟ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਉਹਨਾਂ ਨੇ os-prober ਕਿਉਂ ਜੋੜਿਆ..?ਬਹੁਤ ਜ਼ਿਆਦਾ ਸੁਤੰਤਰਤਾ ਅਤੇ ਖੇਡਣ ਵਾਲੇ ਹੱਥਾਂ ਲਈ.

ਇਹ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰਦਾ ਹੈ ਜੇਕਰ RAIDs ਵਿੱਚੋਂ ਇੱਕ ਡੀਗਰੇਡ ਸਟੇਟ ਵਿੱਚ ਹੈ। ਇਹ ਉਹਨਾਂ ਭਾਗਾਂ ਉੱਤੇ OS ਖੋਜਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਜੋ ਇਸ ਹਾਰਡਵੇਅਰ ਉੱਤੇ ਚੱਲ ਰਹੀਆਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

ਜੇ ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਛੱਡ ਸਕਦੇ ਹੋ, ਪਰ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਗੱਲਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖੋ। ਮੈਂ ਆਨਲਾਈਨ ਸ਼ਰਾਰਤੀ ਹੱਥਾਂ ਤੋਂ ਛੁਟਕਾਰਾ ਪਾਉਣ ਲਈ ਪਕਵਾਨਾਂ ਦੀ ਭਾਲ ਕਰਨ ਦੀ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦਾ ਹਾਂ।

ਇਸਦੇ ਨਾਲ ਅਸੀਂ ਸ਼ੁਰੂਆਤੀ ਸਥਾਪਨਾ ਨੂੰ ਪੂਰਾ ਕਰ ਲਿਆ ਹੈ। ਇਹ ਨਵੇਂ ਸਥਾਪਿਤ OS ਵਿੱਚ ਰੀਬੂਟ ਕਰਨ ਦਾ ਸਮਾਂ ਹੈ। ਬੂਟ ਹੋਣ ਯੋਗ ਲਾਈਵ CD/USB ਨੂੰ ਹਟਾਉਣਾ ਨਾ ਭੁੱਲੋ।

#exit
#reboot

ਬੂਟ ਜੰਤਰ ਦੇ ਤੌਰ ਤੇ SATA SSDs ਵਿੱਚੋਂ ਕੋਈ ਵੀ ਚੁਣੋ।

SATA SSD ਉੱਤੇ LVM

ਇਸ ਮੌਕੇ 'ਤੇ, ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਨਵੇਂ OS ਵਿੱਚ ਬੂਟ ਕਰ ਚੁੱਕੇ ਹਾਂ, ਨੈੱਟਵਰਕ ਨੂੰ ਕੌਂਫਿਗਰ ਕੀਤਾ ਹੈ, apt, ਟਰਮੀਨਲ ਇਮੂਲੇਟਰ ਖੋਲ੍ਹਿਆ ਹੈ, ਅਤੇ ਲਾਂਚ ਕੀਤਾ ਹੈ:

#sudo bash

ਚਲੋ ਜਾਰੀ ਰੱਖੀਏ।

SATA SSD ਤੋਂ ਐਰੇ ਨੂੰ "ਸ਼ੁਰੂ ਕਰੋ":

#blkdiscard /dev/md2

ਜੇ ਇਹ ਕੰਮ ਨਹੀਂ ਕਰਦਾ, ਤਾਂ ਕੋਸ਼ਿਸ਼ ਕਰੋ:

#blkdiscard --step 65536 /dev/md2
SATA SSD 'ਤੇ LVM VG ਬਣਾਓ:

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

ਇੱਕ ਹੋਰ VG ਕਿਉਂ..?ਵਾਸਤਵ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਇੱਕ VG ਨਾਮਕ ਰੂਟ ਹੈ। ਕਿਉਂ ਨਾ ਸਭ ਕੁਝ ਇੱਕ VG ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ?

ਜੇਕਰ ਇੱਕ VG ਵਿੱਚ ਕਈ PVs ਹਨ, ਤਾਂ VG ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਰਗਰਮ ਕਰਨ ਲਈ, ਸਾਰੇ PV ਮੌਜੂਦ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ (ਔਨਲਾਈਨ)। ਅਪਵਾਦ LVM RAID ਹੈ, ਜੋ ਅਸੀਂ ਜਾਣਬੁੱਝ ਕੇ ਨਹੀਂ ਵਰਤਦੇ ਹਾਂ।

ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਜੇਕਰ RAID 6 ਐਰੇ ਵਿੱਚੋਂ ਕਿਸੇ 'ਤੇ ਕੋਈ ਅਸਫਲਤਾ (ਡੇਟਾ ਗੁਆਚਣ) ਹੁੰਦੀ ਹੈ, ਤਾਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਆਮ ਤੌਰ 'ਤੇ ਬੂਟ ਹੋ ਜਾਵੇਗਾ ਅਤੇ ਸਾਨੂੰ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦਾ ਮੌਕਾ ਦੇਵੇਗਾ।

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਐਬਸਟਰੈਕਸ਼ਨ ਦੇ ਪਹਿਲੇ ਪੱਧਰ 'ਤੇ ਅਸੀਂ ਹਰੇਕ ਕਿਸਮ ਦੇ ਭੌਤਿਕ "ਮੀਡੀਆ" ਨੂੰ ਇੱਕ ਵੱਖਰੇ VG ਵਿੱਚ ਅਲੱਗ ਕਰ ਦੇਵਾਂਗੇ।

ਵਿਗਿਆਨਕ ਤੌਰ 'ਤੇ, ਵੱਖ-ਵੱਖ RAID ਐਰੇ ਵੱਖ-ਵੱਖ "ਭਰੋਸੇਯੋਗਤਾ ਡੋਮੇਨਾਂ" ਨਾਲ ਸਬੰਧਤ ਹਨ। ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਇੱਕ VG ਵਿੱਚ ਕ੍ਰੈਮ ਕਰਕੇ ਉਹਨਾਂ ਲਈ ਅਸਫਲਤਾ ਦਾ ਇੱਕ ਵਾਧੂ ਆਮ ਬਿੰਦੂ ਨਹੀਂ ਬਣਾਉਣਾ ਚਾਹੀਦਾ।

"ਹਾਰਡਵੇਅਰ" ਪੱਧਰ 'ਤੇ LVM ਦੀ ਮੌਜੂਦਗੀ ਸਾਨੂੰ ਵੱਖ-ਵੱਖ RAID ਐਰੇ ਦੇ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਜੋੜ ਕੇ ਮਨਮਰਜ਼ੀ ਨਾਲ ਕੱਟਣ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗੀ। ਉਦਾਹਰਨ ਲਈ - ਚਲਾਓ ਉਸੇ ਵੇਲੇ bcache + LVM ਪਤਲਾ, bcache + BTRFS, LVM ਕੈਚ + LVM ਪਤਲਾ, ਕੈਚਾਂ ਦੇ ਨਾਲ ਇੱਕ ਗੁੰਝਲਦਾਰ ZFS ਸੰਰਚਨਾ, ਜਾਂ ਇਸ ਸਭ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਕੋਈ ਹੋਰ ਨਰਕ ਮਿਸ਼ਰਣ।

"ਹਾਰਡਵੇਅਰ" ਪੱਧਰ 'ਤੇ, ਅਸੀਂ ਚੰਗੇ ਪੁਰਾਣੇ "ਮੋਟੇ" LVM ਵਾਲੀਅਮ ਤੋਂ ਇਲਾਵਾ ਹੋਰ ਕੁਝ ਨਹੀਂ ਵਰਤਾਂਗੇ। ਇਸ ਨਿਯਮ ਦਾ ਅਪਵਾਦ ਬੈਕਅੱਪ ਭਾਗ ਹੋ ਸਕਦਾ ਹੈ।

ਮੈਂ ਸੋਚਦਾ ਹਾਂ ਕਿ ਇਸ ਬਿੰਦੂ ਤੱਕ, ਬਹੁਤ ਸਾਰੇ ਪਾਠਕਾਂ ਨੇ ਪਹਿਲਾਂ ਹੀ ਆਲ੍ਹਣੇ ਵਾਲੀ ਗੁੱਡੀ ਬਾਰੇ ਕੁਝ ਸ਼ੱਕ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੱਤਾ ਸੀ.

SATA HDD 'ਤੇ LVM

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

ਦੁਬਾਰਾ ਨਵਾਂ ਵੀ.ਜੀ..?ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਜੇਕਰ ਡਿਸਕ ਐਰੇ ਜੋ ਅਸੀਂ ਡਾਟਾ ਬੈਕਅੱਪ ਲਈ ਵਰਤਾਂਗੇ, ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਾਡਾ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਆਮ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਨਾ ਜਾਰੀ ਰੱਖੇਗਾ, ਜਦੋਂ ਕਿ ਆਮ ਵਾਂਗ ਗੈਰ-ਬੈਕਅੱਪ ਡੇਟਾ ਤੱਕ ਪਹੁੰਚ ਬਣਾਈ ਰੱਖੇਗੀ। ਇਸ ਲਈ, VG ਐਕਟੀਵੇਸ਼ਨ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਣ ਲਈ, ਅਸੀਂ ਇੱਕ ਵੱਖਰਾ VG ਬਣਾਉਂਦੇ ਹਾਂ।

LVM ਕੈਸ਼ ਸੈੱਟਅੱਪ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਚਲੋ ਇਸਨੂੰ ਕੈਚਿੰਗ ਡਿਵਾਈਸ ਦੇ ਤੌਰ ਤੇ ਵਰਤਣ ਲਈ NVMe RAID 1 ਉੱਤੇ ਇੱਕ LV ਬਣਾਈਏ।

#lvcreate -L 70871154688B --name cache root

ਇੰਨਾ ਘੱਟ ਕਿਉਂ ਹੈ...?ਤੱਥ ਇਹ ਹੈ ਕਿ ਸਾਡੇ NVMe SSD ਕੋਲ ਇੱਕ SLC ਕੈਸ਼ ਵੀ ਹੈ। 4-ਬਿੱਟ MLC ਵਿੱਚ ਖਾਲੀ ਥਾਂ ਦੇ ਕਾਰਨ 18 ਗੀਗਾਬਾਈਟ "ਮੁਫ਼ਤ" ਅਤੇ 3 ਗੀਗਾਬਾਈਟ ਡਾਇਨਾਮਿਕ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਇਹ ਕੈਸ਼ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ NVMe SSDs ਕੈਸ਼ ਦੇ ਨਾਲ ਸਾਡੇ SATA SSD ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਤੇਜ਼ ਨਹੀਂ ਹੋਣਗੇ। ਅਸਲ ਵਿੱਚ, ਇਸ ਕਾਰਨ ਕਰਕੇ, ਸਾਡੇ ਲਈ LVM ਕੈਸ਼ ਭਾਗ ਨੂੰ NVMe ਡਰਾਈਵ ਦੇ SLC ਕੈਸ਼ ਦੇ ਆਕਾਰ ਤੋਂ ਦੁੱਗਣਾ ਵੱਡਾ ਬਣਾਉਣਾ ਕੋਈ ਅਰਥ ਨਹੀਂ ਰੱਖਦਾ। ਵਰਤੀਆਂ ਗਈਆਂ NVMe ਡਰਾਈਵਾਂ ਲਈ, ਲੇਖਕ 32-64 ਗੀਗਾਬਾਈਟ ਕੈਸ਼ ਬਣਾਉਣਾ ਜਾਇਜ਼ ਸਮਝਦਾ ਹੈ।

ਦਿੱਤੇ ਭਾਗ ਦਾ ਆਕਾਰ 64 ਗੀਗਾਬਾਈਟ ਕੈਸ਼ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ, ਕੈਸ਼ ਮੈਟਾਡੇਟਾ ਅਤੇ ਮੈਟਾਡੇਟਾ ਦੀ ਬੈਕਅੱਪ ਕਾਪੀ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਲਈ ਲੋੜੀਂਦਾ ਹੈ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਮੈਂ ਨੋਟ ਕਰਦਾ ਹਾਂ ਕਿ ਇੱਕ ਗੰਦੇ ਸਿਸਟਮ ਬੰਦ ਹੋਣ ਤੋਂ ਬਾਅਦ, LVM ਪੂਰੇ ਕੈਸ਼ ਨੂੰ ਗੰਦੇ ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਕਰੇਗਾ ਅਤੇ ਦੁਬਾਰਾ ਸਮਕਾਲੀ ਕਰੇਗਾ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਸ ਨੂੰ ਹਰ ਵਾਰ ਇਸ ਡਿਵਾਈਸ 'ਤੇ lvchange ਦੀ ਵਰਤੋਂ ਕਰਨ 'ਤੇ ਦੁਹਰਾਇਆ ਜਾਵੇਗਾ ਜਦੋਂ ਤੱਕ ਸਿਸਟਮ ਦੁਬਾਰਾ ਚਾਲੂ ਨਹੀਂ ਹੋ ਜਾਂਦਾ ਹੈ। ਇਸ ਲਈ, ਮੈਂ ਢੁਕਵੀਂ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਰੰਤ ਕੈਸ਼ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਉਣ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ.

ਆਉ ਇਸਨੂੰ ਕੈਸ਼ਡ ਡਿਵਾਈਸ ਦੇ ਤੌਰ ਤੇ ਵਰਤਣ ਲਈ SATA RAID 6 ਉੱਤੇ ਇੱਕ LV ਬਣਾਈਏ।

#lvcreate -L 3298543271936B --name cache data

ਸਿਰਫ ਤਿੰਨ ਟੈਰਾਬਾਈਟ ਕਿਉਂ..?ਤਾਂ ਜੋ, ਜੇ ਲੋੜ ਹੋਵੇ, ਤੁਸੀਂ ਕੁਝ ਹੋਰ ਲੋੜਾਂ ਲਈ SATA SSD RAID 6 ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਕੈਸ਼ਡ ਸਪੇਸ ਦਾ ਆਕਾਰ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ, ਫਲਾਈ 'ਤੇ, ਸਿਸਟਮ ਨੂੰ ਰੋਕੇ ਬਿਨਾਂ ਵਧਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਕੈਸ਼ ਨੂੰ ਅਸਥਾਈ ਤੌਰ 'ਤੇ ਬੰਦ ਕਰਨ ਅਤੇ ਮੁੜ-ਯੋਗ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਪਰ LVM-ਕੈਸ਼ ਓਵਰ ਦਾ ਵਿਸ਼ੇਸ਼ ਫਾਇਦਾ, ਉਦਾਹਰਨ ਲਈ, 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 ਪਤਲੇ ਬਲਾਕ ਦੇ ਆਕਾਰ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਆਕਾਰ ਜਿੰਨਾ ਛੋਟਾ ਹੋਵੇਗਾ, ਇੱਕ ਬੇਤਰਤੀਬ ਰਿਕਾਰਡਿੰਗ ਵਿੱਚ ਸੰਰਚਨਾ ਉੱਨੀ ਹੀ ਵਧੀਆ ਹੋਵੇਗੀ।

LVM ਪਤਲੇ ਲਈ 64k ਘੱਟੋ-ਘੱਟ ਬਲਾਕ ਆਕਾਰ ਹੈ।

ਸਾਵਧਾਨ ਰਹੋ ਲਿਖਣਾ..!ਹਾਂ। ਇਸ ਕਿਸਮ ਦਾ ਕੈਸ਼ ਕੈਸ਼ ਕੀਤੇ ਜੰਤਰ ਲਈ ਸਮਕਾਲੀ ਲਿਖਣ ਨੂੰ ਮੁਲਤਵੀ ਕਰਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਜੇਕਰ ਕੈਸ਼ ਗੁੰਮ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਕੈਸ਼ ਕੀਤੇ ਡਿਵਾਈਸ 'ਤੇ ਡਾਟਾ ਗੁਆ ਸਕਦੇ ਹੋ। ਬਾਅਦ ਵਿੱਚ, ਲੇਖਕ ਤੁਹਾਨੂੰ ਦੱਸੇਗਾ ਕਿ ਇਸ ਜੋਖਮ ਦੀ ਪੂਰਤੀ ਲਈ 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

ਦੋ ਨਾਲ ਗੁਣਾ ਕਰੋ ਅਤੇ LVM PV ਮੈਟਾਡੇਟਾ ਲਈ 4194304B ਜੋੜੋ: 8594128896B
ਆਉ ਇਸ ਉੱਤੇ LVM ਪਤਲਾ ਮੈਟਾਡਾਟਾ ਅਤੇ ਉਹਨਾਂ ਦੀ ਬੈਕਅੱਪ ਕਾਪੀ ਰੱਖਣ ਲਈ NVMe RAID 1 ਉੱਤੇ ਇੱਕ ਵੱਖਰਾ ਭਾਗ ਬਣਾਈਏ:

#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 ਕਿਨਾਰੇ-ਅਲਾਈਨ ਹੋ ਜਾਵੇਗਾ। ਇਹ ਕੈਸ਼ ਕੀਤੇ ਡਿਵਾਈਸ ਨੂੰ ਬਾਈਪਾਸ ਕਰਦੇ ਹੋਏ, ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੈਸ਼ ਦੁਆਰਾ ਸੰਚਾਲਨ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ।

ਆਉ 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 ਗੀਗਾਬਾਈਟ ਪ੍ਰਤੀ ਸਕਿੰਟ ਤੱਕ। ਇਸ ਲਈ, ਲਿਖਤੀ ਟੈਸਟਾਂ ਦੀ ਹਰੇਕ ਦੌੜ ਤੁਹਾਡੇ ਤੋਂ 216 ਗੀਗਾਬਾਈਟ SSD ਸਰੋਤ ਖਾ ਸਕਦੀ ਹੈ.

ਪੜ੍ਹਨਾ ਅਤੇ ਲਿਖਣਾ ਮਿਸ਼ਰਤ?ਹਾਂ। ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਦੇ ਟੈਸਟਾਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਚਲਾਉਣਾ ਸਮਝਦਾਰੀ ਰੱਖਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਸਮਝਦਾਰੀ ਰੱਖਦਾ ਹੈ ਕਿ ਸਾਰੇ ਕੈਚ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ ਕੀਤੇ ਗਏ ਹਨ ਤਾਂ ਜੋ ਪਹਿਲਾਂ ਕੀਤੀ ਲਿਖਤ ਪੜ੍ਹਨ ਨੂੰ ਪ੍ਰਭਾਵਤ ਨਾ ਕਰੇ।

ਕੈਸ਼ ਅਤੇ ਪਤਲੇ ਵੌਲਯੂਮ ਭਰਨ ਦੇ ਰੂਪ ਵਿੱਚ ਪਹਿਲੇ ਲਾਂਚ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਨਤੀਜੇ ਬਹੁਤ ਵੱਖਰੇ ਹੋਣਗੇ, ਅਤੇ ਇਹ ਵੀ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਸਿਸਟਮ ਆਖਰੀ ਲਾਂਚ ਦੌਰਾਨ ਭਰੇ ਗਏ ਕੈਚਾਂ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਵਿੱਚ ਕਾਮਯਾਬ ਹੋਇਆ ਸੀ।

ਹੋਰ ਚੀਜ਼ਾਂ ਦੇ ਨਾਲ, ਮੈਂ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਪੂਰੀ ਪਤਲੀ ਵਾਲੀਅਮ 'ਤੇ ਗਤੀ ਨੂੰ ਮਾਪਣ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ ਜਿਸ ਤੋਂ ਇੱਕ ਸਨੈਪਸ਼ਾਟ ਹੁਣੇ ਲਿਆ ਗਿਆ ਸੀ. ਲੇਖਕ ਨੂੰ ਇਹ ਦੇਖਣ ਦਾ ਮੌਕਾ ਮਿਲਿਆ ਕਿ ਕਿਵੇਂ ਬੇਤਰਤੀਬ ਲਿਖਤਾਂ ਪਹਿਲੇ ਸਨੈਪਸ਼ਾਟ ਬਣਾਉਣ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਤੇਜ਼ੀ ਨਾਲ ਤੇਜ਼ ਹੁੰਦੀਆਂ ਹਨ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਕੈਸ਼ ਅਜੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਭਰਿਆ ਨਹੀਂ ਹੁੰਦਾ। ਇਹ ਕਾਪੀ-ਆਨ-ਰਾਈਟ ਰਾਈਟ ਸਿਮੈਨਟਿਕਸ, ਕੈਸ਼ ਦੀ ਅਲਾਈਨਮੈਂਟ ਅਤੇ ਪਤਲੇ ਵਾਲੀਅਮ ਬਲਾਕਾਂ ਦੇ ਕਾਰਨ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਤੱਥ ਕਿ 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 ਦੇ ਸਰੋਤ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਬਚਾਉਂਦਾ ਹੈ।

ਕੋਡ ਕਿੱਥੇ ਹੈ..?ਬਦਕਿਸਮਤੀ ਨਾਲ, ਲੇਖਕ ਆਪਣੇ ਆਪ ਨੂੰ ਬੈਸ਼ ਸਕ੍ਰਿਪਟਾਂ ਦੇ ਵਿਕਾਸ ਵਿੱਚ ਨਾਕਾਫੀ ਤੌਰ 'ਤੇ ਸਮਰੱਥ ਸਮਝਦਾ ਹੈ ਕਿਉਂਕਿ ਉਹ 100% ਸਵੈ-ਸਿਖਿਅਤ ਹੈ ਅਤੇ "ਗੂਗਲ" ਦੁਆਰਾ ਚਲਾਏ ਜਾਣ ਵਾਲੇ ਵਿਕਾਸ ਦਾ ਅਭਿਆਸ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਉਹ ਮੰਨਦਾ ਹੈ ਕਿ ਉਸਦੇ ਹੱਥੋਂ ਨਿਕਲਣ ਵਾਲੇ ਭਿਆਨਕ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਿਸੇ ਦੁਆਰਾ ਨਹੀਂ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ। ਹੋਰ।

ਮੈਂ ਸੋਚਦਾ ਹਾਂ ਕਿ ਇਸ ਖੇਤਰ ਦੇ ਪੇਸ਼ੇਵਰ ਉੱਪਰ ਦੱਸੇ ਗਏ ਸਾਰੇ ਤਰਕ ਨੂੰ ਸੁਤੰਤਰ ਰੂਪ ਵਿੱਚ ਦਰਸਾਉਣ ਦੇ ਯੋਗ ਹੋਣਗੇ, ਜੇ ਲੋੜ ਹੋਵੇ, ਅਤੇ, ਸ਼ਾਇਦ, ਇਸ ਨੂੰ ਇੱਕ ਸਿਸਟਮਡ ਸੇਵਾ ਦੇ ਰੂਪ ਵਿੱਚ ਸੁੰਦਰਤਾ ਨਾਲ ਡਿਜ਼ਾਈਨ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਗੇ, ਜਿਵੇਂ ਕਿ ਲੇਖਕ ਨੇ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਹੈ।

ਅਜਿਹੀ ਇੱਕ ਸਧਾਰਨ ਸਨੈਪਸ਼ਾਟ ਰੋਟੇਸ਼ਨ ਸਕੀਮ ਸਾਨੂੰ ਨਾ ਸਿਰਫ਼ ਇੱਕ ਸਨੈਪਸ਼ਾਟ ਨੂੰ SATA SSD 'ਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਮਕਾਲੀ ਰੱਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗੀ, ਸਗੋਂ ਸਾਨੂੰ thin_delta ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਵੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗੀ ਕਿ ਇਸ ਦੇ ਬਣਨ ਤੋਂ ਬਾਅਦ ਕਿਹੜੇ ਬਲਾਕਾਂ ਨੂੰ ਬਦਲਿਆ ਗਿਆ ਸੀ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਨੁਕਸਾਨ ਦਾ ਸਥਾਨੀਕਰਨ ਕਰੋ। ਮੁੱਖ ਵੌਲਯੂਮ, ਰਿਕਵਰੀ ਨੂੰ ਬਹੁਤ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ।

libvirt/KVM ਵਿੱਚ ਟ੍ਰਿਮ/ਡਿਸਕਾਰਡ

ਕਿਉਂਕਿ ਡਾਟਾ ਸਟੋਰੇਜ਼ ਨੂੰ KVM ਚੱਲ ਰਹੇ libvirt ਲਈ ਵਰਤਿਆ ਜਾਵੇਗਾ, ਤਾਂ ਇਹ ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਹੋਵੇਗਾ ਕਿ ਅਸੀਂ ਆਪਣੇ VM ਨੂੰ ਨਾ ਸਿਰਫ਼ ਖਾਲੀ ਥਾਂ ਲੈਣੀ ਸਿਖਾਈਏ, ਸਗੋਂ ਉਸ ਨੂੰ ਖਾਲੀ ਕਰਨ ਲਈ ਵੀ ਜਿਸਦੀ ਹੁਣ ਲੋੜ ਨਹੀਂ ਹੈ।

ਇਹ ਵਰਚੁਅਲ ਡਿਸਕਾਂ 'ਤੇ TRIM/DISCARD ਸਮਰਥਨ ਦੀ ਨਕਲ ਕਰਕੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਕੰਟਰੋਲਰ ਦੀ ਕਿਸਮ ਨੂੰ virtio-scsi ਵਿੱਚ ਬਦਲਣ ਅਤੇ xml ਨੂੰ ਸੋਧਣ ਦੀ ਲੋੜ ਹੈ।

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

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

ਗੈਸਟ OS ਤੋਂ ਅਜਿਹੇ ਡਿਸਕਾਰਡਾਂ ਨੂੰ LVM ਦੁਆਰਾ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰੋਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਬਲਾਕਾਂ ਨੂੰ ਕੈਸ਼ ਅਤੇ ਪਤਲੇ ਪੂਲ ਦੋਵਾਂ ਵਿੱਚ ਸਹੀ ਢੰਗ ਨਾਲ ਮੁਕਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਹ ਮੁੱਖ ਤੌਰ 'ਤੇ ਇੱਕ ਦੇਰੀ ਨਾਲ ਵਾਪਰਦਾ ਹੈ, ਜਦੋਂ ਅਗਲੇ ਸਨੈਪਸ਼ਾਟ ਨੂੰ ਮਿਟਾਉਂਦੇ ਹੋ।

BTRFS ਬੈਕਅੱਪ

ਨਾਲ ਤਿਆਰ ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤਿ ਸਾਵਧਾਨੀ ਅਤੇ ਆਪਣੇ ਖੁਦ ਦੇ ਜੋਖਮ 'ਤੇ. ਲੇਖਕ ਨੇ ਇਹ ਕੋਡ ਆਪਣੇ ਆਪ ਅਤੇ ਸਿਰਫ਼ ਆਪਣੇ ਲਈ ਹੀ ਲਿਖਿਆ ਹੈ। ਮੈਨੂੰ ਯਕੀਨ ਹੈ ਕਿ ਬਹੁਤ ਸਾਰੇ ਤਜਰਬੇਕਾਰ ਲੀਨਕਸ ਉਪਭੋਗਤਾਵਾਂ ਕੋਲ ਸਮਾਨ ਸਾਧਨ ਹਨ, ਅਤੇ ਕਿਸੇ ਹੋਰ ਦੀ ਨਕਲ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ.

ਆਉ ਬੈਕਅੱਪ ਡਿਵਾਈਸ ਤੇ ਇੱਕ ਵਾਲੀਅਮ ਬਣਾਈਏ:

#lvcreate -L 256G --name backup backup

ਆਓ ਇਸਨੂੰ BTRFS ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੀਏ:

#mkfs.btrfs /dev/backup/backup

ਆਉ ਮਾਊਂਟ ਪੁਆਇੰਟ ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਫਾਈਲ ਸਿਸਟਮ ਦੇ ਰੂਟ ਉਪ ਭਾਗਾਂ ਨੂੰ ਮਾਊਂਟ ਕਰਦੇ ਹਾਂ:

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

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

ਆਓ ਬੈਕਅੱਪ ਲਈ ਡਾਇਰੈਕਟਰੀਆਂ ਬਣਾਈਏ:

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

ਆਓ ਬੈਕਅੱਪ ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਬਣਾਈਏ:

#mkdir /root/btrfs-backup

ਆਉ ਸਕ੍ਰਿਪਟ ਦੀ ਨਕਲ ਕਰੀਏ:

ਬਹੁਤ ਸਾਰੇ ਡਰਾਉਣੇ ਬੈਸ਼ ਕੋਡ. ਆਪਣੇ ਖੁਦ ਦੇ ਜੋਖਮ 'ਤੇ ਵਰਤੋ. ਲੇਖਕ ਨੂੰ ਨਾਰਾਜ਼ ਚਿੱਠੀਆਂ ਨਾ ਲਿਖੋ...#cat >/root/btrfs-backup/btrfs-backup.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

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

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

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

function wait_lock()
{
flock 98
}

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

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

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

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

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

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

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

}

(
COMMAND="$1"
shift

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

EOF


ਇਹ ਵੀ ਕੀ ਕਰਦਾ..?BTRFS ਸਨੈਪਸ਼ਾਟ ਬਣਾਉਣ ਅਤੇ BTRFS ਭੇਜਣ/ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹਨਾਂ ਨੂੰ ਕਿਸੇ ਹੋਰ FS 'ਤੇ ਕਾਪੀ ਕਰਨ ਲਈ ਸਧਾਰਨ ਕਮਾਂਡਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।

ਪਹਿਲਾ ਲਾਂਚ ਮੁਕਾਬਲਤਨ ਲੰਬਾ ਹੋ ਸਕਦਾ ਹੈ, ਕਿਉਂਕਿ... ਸ਼ੁਰੂ ਵਿੱਚ, ਸਾਰਾ ਡਾਟਾ ਕਾਪੀ ਕੀਤਾ ਜਾਵੇਗਾ. ਹੋਰ ਲਾਂਚ ਬਹੁਤ ਤੇਜ਼ ਹੋਣਗੇ, ਕਿਉਂਕਿ... ਸਿਰਫ਼ ਤਬਦੀਲੀਆਂ ਹੀ ਕਾਪੀ ਕੀਤੀਆਂ ਜਾਣਗੀਆਂ।

ਇੱਕ ਹੋਰ ਸਕ੍ਰਿਪਟ ਜੋ ਅਸੀਂ ਕ੍ਰੋਨ ਵਿੱਚ ਪਾਵਾਂਗੇ:

ਕੁਝ ਹੋਰ ਬੈਸ਼ ਕੋਡ#cat >/root/btrfs-backup/cron-daily.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

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

BACKUP_SCRIPT="$SCRIPT_DIR/btrfs-backup.sh"
RETENTION="-60 day"
$BACKUP_SCRIPT backup root/@
$BACKUP_SCRIPT removeall root/@ "$RETENTION"
$BACKUP_SCRIPT backup root/@home
$BACKUP_SCRIPT removeall root/@home "$RETENTION"
$BACKUP_SCRIPT backup boot/
$BACKUP_SCRIPT removeall boot/ "$RETENTION"
EOF


ਇਹ ਕੀ ਕਰਦਾ ਹੈ..?ਬੈਕਅੱਪ FS 'ਤੇ ਸੂਚੀਬੱਧ BTRFS ਵਾਲੀਅਮਾਂ ਦੇ ਵਾਧੇ ਵਾਲੇ ਸਨੈਪਸ਼ਾਟ ਬਣਾਉਂਦਾ ਅਤੇ ਸਮਕਾਲੀ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਾਅਦ ਇਹ 60 ਦਿਨ ਪਹਿਲਾਂ ਬਣਾਈਆਂ ਗਈਆਂ ਸਾਰੀਆਂ ਤਸਵੀਰਾਂ ਨੂੰ ਡਿਲੀਟ ਕਰ ਦਿੰਦਾ ਹੈ। ਲਾਂਚ ਤੋਂ ਬਾਅਦ, ਸੂਚੀਬੱਧ ਵਾਲੀਅਮਾਂ ਦੇ ਮਿਤੀ ਵਾਲੇ ਸਨੈਪਸ਼ਾਟ /backup/btrfs/back/remote/ ਸਬ-ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਦਿਖਾਈ ਦੇਣਗੇ।

ਚਲੋ ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਅਧਿਕਾਰ ਦਿੰਦੇ ਹਾਂ:

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

ਚਲੋ ਇਸਦੀ ਜਾਂਚ ਕਰੀਏ ਅਤੇ ਇਸਨੂੰ ਕ੍ਰੋਨ ਵਿੱਚ ਪਾਈਏ:

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


LVM ਪਤਲਾ ਬੈਕਅੱਪ

ਆਉ ਬੈਕਅੱਪ ਡਿਵਾਈਸ ਤੇ ਇੱਕ ਪਤਲਾ ਪੂਲ ਬਣਾਈਏ:

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

ਚਲੋ ddrescue ਇੰਸਟਾਲ ਕਰੀਏ, ਕਿਉਂਕਿ... ਸਕ੍ਰਿਪਟ ਇਸ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰੇਗੀ:

#apt-get install gddrescue

ਆਉ ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਬਣਾਈਏ:

#mkdir /root/lvm-thin-backup

ਆਉ ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਨਕਲ ਕਰੀਏ:

ਅੰਦਰੋਂ ਬਹੁਤ ਧੱਕਾ...#cat >/root/lvm-thin-backup/lvm-thin-backup.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

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

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

export LVM_SUPPRESS_FD_WARNINGS=1

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

function wait_lock()
{
flock 98
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

dmsetup message $DIFF_POOL_PATH_TPOOL 0 release_metadata_snap

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

}

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

activate_volume $SYNC_VG $SYNC_PEND

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

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

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

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

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

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

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

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

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

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

echo Syncronizing "$SOURCE_BASE_LV_PATH" to "$TARGET_BASE_LV_PATH"

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

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

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

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

}

(
COMMAND="$1"
shift

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

EOF


ਇਹ ਕੀ ਕਰਦਾ ਹੈ...?ਪਤਲੇ ਸਨੈਪਸ਼ਾਟ ਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਨ ਅਤੇ 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


ਇਹ ਕੀ ਕਰਦਾ ਹੈ...?ਸੂਚੀਬੱਧ ਪਤਲੇ ਵਾਲੀਅਮ ਦੇ ਬੈਕਅੱਪ ਬਣਾਉਣ ਅਤੇ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਪਿਛਲੀ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਸਕ੍ਰਿਪਟ ਸੂਚੀਬੱਧ ਵਾਲੀਅਮਾਂ ਦੇ ਅਕਿਰਿਆਸ਼ੀਲ ਸਨੈਪਸ਼ਾਟ ਛੱਡ ਦੇਵੇਗੀ, ਜੋ ਕਿ ਆਖਰੀ ਸਮਕਾਲੀਕਰਨ ਤੋਂ ਬਾਅਦ ਤਬਦੀਲੀਆਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਲੋੜੀਂਦੇ ਹਨ।

ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸੰਪਾਦਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਪਤਲੇ ਵਾਲੀਅਮਾਂ ਦੀ ਸੂਚੀ ਦੱਸਦੀ ਹੈ ਜਿਸ ਲਈ ਬੈਕਅੱਪ ਕਾਪੀਆਂ ਬਣਾਈਆਂ ਜਾਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ। ਦਿੱਤੇ ਗਏ ਨਾਮ ਸਿਰਫ ਵਿਆਖਿਆ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ ਚਾਹੋ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖ ਸਕਦੇ ਹੋ ਜੋ ਸਾਰੀਆਂ ਵਾਲੀਅਮਾਂ ਨੂੰ ਸਮਕਾਲੀ ਬਣਾਵੇਗੀ।

ਆਓ ਅਧਿਕਾਰ ਦੇਈਏ:

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

ਚਲੋ ਇਸਦੀ ਜਾਂਚ ਕਰੀਏ ਅਤੇ ਇਸਨੂੰ ਕ੍ਰੋਨ ਵਿੱਚ ਪਾਈਏ:

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

ਪਹਿਲਾ ਲਾਂਚ ਲੰਬਾ ਹੋਵੇਗਾ, ਕਿਉਂਕਿ... ਪਤਲੇ ਵਾਲੀਅਮ ਸਾਰੇ ਵਰਤੀ ਗਈ ਥਾਂ ਦੀ ਨਕਲ ਕਰਕੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਮਕਾਲੀ ਹੋ ਜਾਣਗੇ। LVM ਪਤਲੇ ਮੈਟਾਡੇਟਾ ਲਈ ਧੰਨਵਾਦ, ਅਸੀਂ ਜਾਣਦੇ ਹਾਂ ਕਿ ਅਸਲ ਵਿੱਚ ਕਿਹੜੇ ਬਲਾਕ ਵਰਤੋਂ ਵਿੱਚ ਹਨ, ਇਸਲਈ ਅਸਲ ਵਿੱਚ ਵਰਤੇ ਗਏ ਪਤਲੇ ਵਾਲੀਅਮ ਬਲਾਕਾਂ ਦੀ ਹੀ ਨਕਲ ਕੀਤੀ ਜਾਵੇਗੀ।

ਅਗਲੀਆਂ ਦੌੜਾਂ LVM ਪਤਲੇ ਮੈਟਾਡੇਟਾ ਦੁਆਰਾ ਟਰੈਕਿੰਗ ਨੂੰ ਬਦਲਣ ਲਈ ਧੰਨਵਾਦੀ ਤੌਰ 'ਤੇ ਡੇਟਾ ਦੀ ਨਕਲ ਕਰਨਗੇ।

ਆਓ ਦੇਖੀਏ ਕੀ ਹੋਇਆ:

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

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

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

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


ਇਸ ਦਾ ਆਲ੍ਹਣੇ ਦੀਆਂ ਗੁੱਡੀਆਂ ਨਾਲ ਕੀ ਸਬੰਧ ਹੈ?

ਬਹੁਤੀ ਸੰਭਾਵਨਾ ਹੈ, ਕਿ LVM LV ਲਾਜ਼ੀਕਲ ਵਾਲੀਅਮ ਦੂਜੇ VG ਲਈ LVM PV ਭੌਤਿਕ ਵਾਲੀਅਮ ਹੋ ਸਕਦੇ ਹਨ। LVM ਆਵਰਤੀ ਹੋ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਨੇਸਟਿੰਗ ਡੌਲਸ। ਇਹ LVM ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਲਚਕਤਾ ਦਿੰਦਾ ਹੈ।

PS

ਅਗਲੇ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਘਰੇਲੂ ਡੈਸਕਟਾਪਾਂ, ਘਰੇਲੂ ਇੰਟਰਨੈਟ ਅਤੇ P2P ਨੈੱਟਵਰਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਈ ਮਹਾਂਦੀਪਾਂ ਵਿੱਚ ਰਿਡੰਡੈਂਸੀ ਦੇ ਨਾਲ ਇੱਕ ਜਿਓ-ਡਿਸਟ੍ਰੀਬਿਊਟਡ ਸਟੋਰੇਜ/vm ਕਲੱਸਟਰ ਬਣਾਉਣ ਦੇ ਆਧਾਰ ਵਜੋਂ ਕਈ ਸਮਾਨ ਮੋਬਾਈਲ ਸਟੋਰੇਜ ਸਿਸਟਮ/KVM ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ।

ਸਰੋਤ: www.habr.com