ಪ್ರೊಹೋಸ್ಟರ್ > Блог > ಆಡಳಿತ > LVM ಮತ್ತು Matryoshka ಸಾಮಾನ್ಯವಾಗಿ ಏನು ಹೊಂದಿವೆ?

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 ತೆಳುವಾದ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳು ಮತ್ತು ಥಿನ್_ಡೆಲ್ಟಾವನ್ನು ಬಳಸುವುದು.

ನಿಮಗೆ ಆಸಕ್ತಿ ಇದ್ದರೆ, ದಯವಿಟ್ಟು ಬೆಕ್ಕು ನೋಡಿ.

ಅರ್ಜಿ ನಮೂನೆ

ಈ ಲೇಖನದಿಂದ ಸಾಮಗ್ರಿಗಳು/ಉದಾಹರಣೆಗಳು/ಕೋಡ್/ಸಲಹೆಗಳು/ಡೇಟಾವನ್ನು ಬಳಸುವ ಅಥವಾ ಬಳಸದಿರುವ ಪರಿಣಾಮಗಳಿಗೆ ಲೇಖಕರು ಯಾವುದೇ ಜವಾಬ್ದಾರರಾಗಿರುವುದಿಲ್ಲ. ಈ ವಿಷಯವನ್ನು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಓದುವ ಅಥವಾ ಬಳಸುವ ಮೂಲಕ, ಈ ಕ್ರಿಯೆಗಳ ಎಲ್ಲಾ ಪರಿಣಾಮಗಳಿಗೆ ನೀವು ಜವಾಬ್ದಾರರಾಗಿರುತ್ತೀರಿ. ಸಂಭವನೀಯ ಪರಿಣಾಮಗಳು ಸೇರಿವೆ:

  • ಕ್ರಿಸ್ಪ್-ಫ್ರೈಡ್ NVMe SSD ಗಳು.
  • ರೆಕಾರ್ಡಿಂಗ್ ಸಂಪನ್ಮೂಲ ಮತ್ತು SSD ಡ್ರೈವ್‌ಗಳ ವೈಫಲ್ಯವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಳಸಲಾಗಿದೆ.
  • ಬ್ಯಾಕಪ್ ಪ್ರತಿಗಳು ಸೇರಿದಂತೆ ಎಲ್ಲಾ ಡ್ರೈವ್‌ಗಳಲ್ಲಿನ ಎಲ್ಲಾ ಡೇಟಾದ ಸಂಪೂರ್ಣ ನಷ್ಟ.
  • ದೋಷಪೂರಿತ ಕಂಪ್ಯೂಟರ್ ಯಂತ್ರಾಂಶ.
  • ಸಮಯ, ನರಗಳು ಮತ್ತು ಹಣ ವ್ಯರ್ಥ.
  • ಮೇಲೆ ಪಟ್ಟಿ ಮಾಡದ ಯಾವುದೇ ಇತರ ಪರಿಣಾಮಗಳು.

ಕಬ್ಬಿಣ

ಲಭ್ಯವಿವೆ:

ಸುಮಾರು 2013 ರಿಂದ Z87 ಚಿಪ್‌ಸೆಟ್‌ನೊಂದಿಗೆ ಮದರ್‌ಬೋರ್ಡ್, ಇಂಟೆಲ್ ಕೋರ್ i7 / ಹ್ಯಾಸ್‌ವೆಲ್‌ನೊಂದಿಗೆ ಪೂರ್ಣಗೊಂಡಿದೆ.

  • ಪ್ರೊಸೆಸರ್ 4 ಕೋರ್ಗಳು, 8 ಥ್ರೆಡ್ಗಳು
  • 32 GB DDR3 RAM
  • 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, ಸಾಮಾನ್ಯವಾಗಿ, ಬಸ್‌ನಲ್ಲಿ ಯಾವ ಆಜ್ಞೆಗಳನ್ನು ರವಾನಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸುವುದಿಲ್ಲ.

ಹಾರ್ಡ್ ಡ್ರೈವ್‌ಗಳು - HGST ಟ್ರಾವೆಲ್‌ಸ್ಟಾರ್ 8K7 ನ 1000 ತುಣುಕುಗಳು, ಲ್ಯಾಪ್‌ಟಾಪ್‌ಗಳಂತೆ 1 ಫಾರ್ಮ್ ಫ್ಯಾಕ್ಟರ್‌ನಲ್ಲಿ 2.5 TB ಸಾಮರ್ಥ್ಯ. ಈ ಡ್ರೈವ್‌ಗಳು ಹಿಂದೆ RAID 6 ರಚನೆಯಲ್ಲಿತ್ತು. ಹೊಸ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಅವುಗಳ ಉಪಯೋಗವೂ ಇರುತ್ತದೆ. ಸ್ಥಳೀಯ ಬ್ಯಾಕ್‌ಅಪ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು.

ಹೆಚ್ಚುವರಿಯಾಗಿ ಸೇರಿಸಲಾಗಿದೆ:

6 ತುಣುಕುಗಳು SATA SSD ಮಾದರಿ Samsung 860 QVO 2TB. ಈ SSD ಗಳಿಗೆ ದೊಡ್ಡ ಪರಿಮಾಣದ ಅಗತ್ಯವಿದೆ, SLC ಸಂಗ್ರಹದ ಉಪಸ್ಥಿತಿ, ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ಕಡಿಮೆ ಬೆಲೆ ಅಪೇಕ್ಷಣೀಯವಾಗಿದೆ. ತಿರಸ್ಕರಿಸು/ಶೂನ್ಯಕ್ಕೆ ಬೆಂಬಲದ ಅಗತ್ಯವಿದೆ, ಇದನ್ನು dmesg ನಲ್ಲಿನ ಸಾಲಿನ ಮೂಲಕ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ:

kernel: ata1.00: Enabling discard_zeroes_data

NVMe SSD ಮಾದರಿಯ 2 ತುಣುಕುಗಳು Samsung SSD 970 EVO 500GB.

ಈ SSD ಗಳಿಗೆ, ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗಾಗಿ ಯಾದೃಚ್ಛಿಕ ಓದುವ/ಬರೆಯುವ ವೇಗ ಮತ್ತು ಸಂಪನ್ಮೂಲ ಸಾಮರ್ಥ್ಯವು ಮುಖ್ಯವಾಗಿದೆ. ಅವರಿಗೆ ರೇಡಿಯೇಟರ್. ಅಗತ್ಯವಾಗಿ. ಸಂಪೂರ್ಣವಾಗಿ. ಇಲ್ಲದಿದ್ದರೆ, ಮೊದಲ RAID ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಸಮಯದಲ್ಲಿ ಗರಿಗರಿಯಾಗುವವರೆಗೆ ಅವುಗಳನ್ನು ಫ್ರೈ ಮಾಡಿ.

8 x NVMe SSD ಗಾಗಿ StarTech PEX2M2E2 ಅಡಾಪ್ಟರ್ ಅನ್ನು PCIe 3.0 8x ಸ್ಲಾಟ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ. ಇದು ಮತ್ತೊಮ್ಮೆ, ಕೇವಲ HBA ಆಗಿದೆ, ಆದರೆ NVMe ಗಾಗಿ. ಇದು ಅಗ್ಗದ ಅಡಾಪ್ಟರ್‌ಗಳಿಂದ ಭಿನ್ನವಾಗಿದೆ, ಇದರಲ್ಲಿ ಅಂತರ್ನಿರ್ಮಿತ PCIe ಸ್ವಿಚ್ ಇರುವ ಕಾರಣ ಮದರ್‌ಬೋರ್ಡ್‌ನಿಂದ PCIe ಕವಲೊಡೆಯುವಿಕೆ ಬೆಂಬಲದ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ. ಇದು x1 PCIe 1.0 ಸ್ಲಾಟ್ ಆಗಿದ್ದರೂ, PCIe ಜೊತೆಗಿನ ಅತ್ಯಂತ ಪುರಾತನ ವ್ಯವಸ್ಥೆಯಲ್ಲಿಯೂ ಸಹ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಸ್ವಾಭಾವಿಕವಾಗಿ, ಸರಿಯಾದ ವೇಗದಲ್ಲಿ. ಅಲ್ಲಿ ಯಾವುದೇ RAID ಗಳಿಲ್ಲ. ಮಂಡಳಿಯಲ್ಲಿ ಯಾವುದೇ ಅಂತರ್ನಿರ್ಮಿತ BIOS ಇಲ್ಲ. ಆದ್ದರಿಂದ, ನಿಮ್ಮ ಸಿಸ್ಟಮ್ NVMe ನೊಂದಿಗೆ ಬೂಟ್ ಮಾಡಲು ಮಾಂತ್ರಿಕವಾಗಿ ಕಲಿಯುವುದಿಲ್ಲ, ಈ ಸಾಧನಕ್ಕೆ NVMe RAID ಧನ್ಯವಾದಗಳು.

ಈ ಘಟಕವು ಸಿಸ್ಟಂನಲ್ಲಿ ಕೇವಲ ಒಂದು ಉಚಿತ 8x PCIe 3.0 ಇರುವಿಕೆಯಿಂದಾಗಿ ಮತ್ತು 2 ಉಚಿತ ಸ್ಲಾಟ್‌ಗಳಿದ್ದರೆ, ಅದನ್ನು ಸುಲಭವಾಗಿ ಎರಡು ಪೆನ್ನಿ PEX4M2E1 ಅಥವಾ ಅನಲಾಗ್‌ಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸಬಹುದು, ಅದನ್ನು 600 ಬೆಲೆಗೆ ಎಲ್ಲಿ ಬೇಕಾದರೂ ಖರೀದಿಸಬಹುದು. ರೂಬಲ್ಸ್ಗಳನ್ನು.

ಎಲ್ಲಾ ರೀತಿಯ ಹಾರ್ಡ್‌ವೇರ್ ಅಥವಾ ಬಿಲ್ಟ್-ಇನ್ ಚಿಪ್‌ಸೆಟ್/BIOS RAIDಗಳ ನಿರಾಕರಣೆಯನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಮಾಡಲಾಗಿದ್ದು, ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಸಂರಕ್ಷಿಸುವಾಗ, SSD/HDD ಅನ್ನು ಹೊರತುಪಡಿಸಿ, ಸಂಪೂರ್ಣ ಸಿಸ್ಟಮ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ತಾತ್ತ್ವಿಕವಾಗಿ, ಸಂಪೂರ್ಣವಾಗಿ ಹೊಸ / ವಿಭಿನ್ನ ಹಾರ್ಡ್‌ವೇರ್‌ಗೆ ಚಲಿಸುವಾಗ ನೀವು ಸ್ಥಾಪಿಸಲಾದ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಸಹ ಉಳಿಸಬಹುದು. ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ SATA ಮತ್ತು PCIe ಪೋರ್ಟ್‌ಗಳಿವೆ. ಇದು ಲೈವ್ ಸಿಡಿ ಅಥವಾ ಬೂಟ್ ಮಾಡಬಹುದಾದ ಫ್ಲ್ಯಾಷ್ ಡ್ರೈವ್‌ನಂತಿದೆ, ಇದು ತುಂಬಾ ವೇಗವಾಗಿ ಮತ್ತು ಸ್ವಲ್ಪ ದೊಡ್ಡದಾಗಿದೆ.

ಹಾಸ್ಯಇಲ್ಲದಿದ್ದರೆ, ಏನಾಗುತ್ತದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ - ಕೆಲವೊಮ್ಮೆ ನೀವು ತುರ್ತಾಗಿ ನಿಮ್ಮೊಂದಿಗೆ ಸಂಪೂರ್ಣ ಶ್ರೇಣಿಯನ್ನು ತೆಗೆದುಕೊಂಡು ಹೋಗಬೇಕಾಗುತ್ತದೆ. ಆದರೆ ನಾನು ಡೇಟಾವನ್ನು ಕಳೆದುಕೊಳ್ಳಲು ಬಯಸುವುದಿಲ್ಲ. ಇದನ್ನು ಮಾಡಲು, ಎಲ್ಲಾ ಉಲ್ಲೇಖಿಸಲಾದ ಮಾಧ್ಯಮಗಳು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಕೇಸ್ನ 5.25 ಕೊಲ್ಲಿಗಳಲ್ಲಿ ಸ್ಲೈಡ್ಗಳಲ್ಲಿ ಅನುಕೂಲಕರವಾಗಿ ನೆಲೆಗೊಂಡಿವೆ.

ಸರಿ, ಮತ್ತು, ಸಹಜವಾಗಿ, ಲಿನಕ್ಸ್‌ನಲ್ಲಿ SSD ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಪ್ರಯೋಗಿಸಲು.

ಹಾರ್ಡ್‌ವೇರ್ ದಾಳಿಗಳು ನೀರಸವಾಗಿವೆ. ಅದನ್ನು ಆನ್ ಮಾಡಿ. ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ ಅಥವಾ ಇಲ್ಲ. ಮತ್ತು mdadm ನೊಂದಿಗೆ ಯಾವಾಗಲೂ ಆಯ್ಕೆಗಳಿವೆ.

ಮೃದು

ಹಿಂದೆ, ಡೆಬಿಯನ್ 8 ಜೆಸ್ಸಿಯನ್ನು ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾಯಿತು, ಇದು EOL ಗೆ ಹತ್ತಿರದಲ್ಲಿದೆ. RAID 6 ಅನ್ನು LVM ನೊಂದಿಗೆ ಜೋಡಿಸಲಾದ ಮೇಲೆ ತಿಳಿಸಲಾದ HDD ಗಳಿಂದ ಜೋಡಿಸಲಾಗಿದೆ. ಇದು kvm/libvirt ನಲ್ಲಿ ವರ್ಚುವಲ್ ಯಂತ್ರಗಳನ್ನು ನಡೆಸಿತು.

ಏಕೆಂದರೆ ಪೋರ್ಟಬಲ್ ಬೂಟ್ ಮಾಡಬಹುದಾದ SATA/NVMe ಫ್ಲ್ಯಾಷ್ ಡ್ರೈವ್‌ಗಳನ್ನು ರಚಿಸುವಲ್ಲಿ ಲೇಖಕರಿಗೆ ಸೂಕ್ತವಾದ ಅನುಭವವಿದೆ, ಮತ್ತು ಸಾಮಾನ್ಯ ಸೂಕ್ತವಾದ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಮುರಿಯದಿರಲು, ಉಬುಂಟು 18.04 ಅನ್ನು ಗುರಿ ವ್ಯವಸ್ಥೆಯಾಗಿ ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ, ಇದು ಈಗಾಗಲೇ ಸಾಕಷ್ಟು ಸ್ಥಿರವಾಗಿದೆ, ಆದರೆ ಇನ್ನೂ 3 ವರ್ಷಗಳನ್ನು ಹೊಂದಿದೆ. ಭವಿಷ್ಯದಲ್ಲಿ ಬೆಂಬಲ.

ಉಲ್ಲೇಖಿಸಲಾದ ಸಿಸ್ಟಮ್ ನಮಗೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಹಾರ್ಡ್‌ವೇರ್ ಡ್ರೈವರ್‌ಗಳನ್ನು ಬಾಕ್ಸ್‌ನ ಹೊರಗೆ ಒಳಗೊಂಡಿದೆ. ನಮಗೆ ಯಾವುದೇ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಸಾಫ್ಟ್‌ವೇರ್ ಅಥವಾ ಡ್ರೈವರ್‌ಗಳ ಅಗತ್ಯವಿಲ್ಲ.

ಅನುಸ್ಥಾಪನೆಗೆ ಸಿದ್ಧತೆ

ಸಿಸ್ಟಮ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು ನಮಗೆ ಉಬುಂಟು ಡೆಸ್ಕ್‌ಟಾಪ್ ಇಮೇಜ್ ಅಗತ್ಯವಿದೆ. ಸರ್ವರ್ ಸಿಸ್ಟಮ್ ಕೆಲವು ರೀತಿಯ ಹುರುಪಿನ ಅನುಸ್ಥಾಪಕವನ್ನು ಹೊಂದಿದೆ, ಇದು UEFI ಸಿಸ್ಟಮ್ ವಿಭಾಗವನ್ನು ಡಿಸ್ಕ್ಗಳಲ್ಲಿ ಒಂದಕ್ಕೆ ತಳ್ಳುವ ಮೂಲಕ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗದ ಅತಿಯಾದ ಸ್ವಾತಂತ್ರ್ಯವನ್ನು ತೋರಿಸುತ್ತದೆ, ಎಲ್ಲಾ ಸೌಂದರ್ಯವನ್ನು ಹಾಳುಮಾಡುತ್ತದೆ. ಅಂತೆಯೇ, ಇದನ್ನು UEFI ಮೋಡ್‌ನಲ್ಲಿ ಮಾತ್ರ ಸ್ಥಾಪಿಸಲಾಗಿದೆ. ಯಾವುದೇ ಆಯ್ಕೆಗಳನ್ನು ನೀಡುವುದಿಲ್ಲ.

ಇದರಿಂದ ನಮಗೆ ಸಂತೋಷವಿಲ್ಲ.

ಯಾಕೆ?ದುರದೃಷ್ಟವಶಾತ್, UEFI ಬೂಟ್ ಬೂಟ್ ಸಾಫ್ಟ್‌ವೇರ್ RAID ನೊಂದಿಗೆ ಅತ್ಯಂತ ಕಳಪೆಯಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ, ಏಕೆಂದರೆ... UEFI ESP ವಿಭಜನೆಗಾಗಿ ಯಾರೂ ನಮಗೆ ಮೀಸಲಾತಿಯನ್ನು ನೀಡುವುದಿಲ್ಲ. ಯುಎಸ್‌ಬಿ ಪೋರ್ಟ್‌ನಲ್ಲಿ ಫ್ಲ್ಯಾಷ್ ಡ್ರೈವ್‌ನಲ್ಲಿ ಇಎಸ್‌ಪಿ ವಿಭಾಗವನ್ನು ಇರಿಸಲು ಸೂಚಿಸುವ ಪಾಕವಿಧಾನಗಳು ಆನ್‌ಲೈನ್‌ನಲ್ಲಿವೆ, ಆದರೆ ಇದು ವೈಫಲ್ಯದ ಹಂತವಾಗಿದೆ. ಮೆಟಾಡೇಟಾ ಆವೃತ್ತಿ 1 ನೊಂದಿಗೆ ಸಾಫ್ಟ್‌ವೇರ್ mdadm RAID 0.9 ಅನ್ನು ಬಳಸುವ ಪಾಕವಿಧಾನಗಳಿವೆ, ಅದು UEFI BIOS ಅನ್ನು ಈ ವಿಭಾಗವನ್ನು ನೋಡುವುದನ್ನು ತಡೆಯುವುದಿಲ್ಲ, ಆದರೆ BIOS ಅಥವಾ ಇನ್ನೊಂದು ಹಾರ್ಡ್‌ವೇರ್ OS ESP ಗೆ ಏನನ್ನಾದರೂ ಬರೆದಾಗ ಮತ್ತು ಅದನ್ನು ಇತರಕ್ಕೆ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ಮರೆತುಹೋದ ಸಂತೋಷದ ಕ್ಷಣದವರೆಗೆ ಇದು ಜೀವಿಸುತ್ತದೆ. ಕನ್ನಡಿಗರು.

ಹೆಚ್ಚುವರಿಯಾಗಿ, UEFI ಬೂಟ್ NVRAM ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ, ಇದು ಡಿಸ್ಕ್ಗಳೊಂದಿಗೆ ಹೊಸ ಸಿಸ್ಟಮ್ಗೆ ಚಲಿಸುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಮದರ್ಬೋರ್ಡ್ನ ಭಾಗವಾಗಿದೆ.

ಆದ್ದರಿಂದ, ನಾವು ಹೊಸ ಚಕ್ರವನ್ನು ಮರುಶೋಧಿಸುವುದಿಲ್ಲ. UEFI-ಹೊಂದಾಣಿಕೆಯ ಸಿಸ್ಟಂಗಳಲ್ಲಿ CSM ಎಂಬ ಹೆಮ್ಮೆಯ ಹೆಸರನ್ನು ಹೊಂದಿರುವ, ಈಗ ಲೆಗಸಿ/BIOS ಬೂಟ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ, ಸಿದ್ಧವಾದ, ಸಮಯ-ಪರೀಕ್ಷಿತ ಅಜ್ಜನ ಬೈಕ್ ಅನ್ನು ನಾವು ಈಗಾಗಲೇ ಹೊಂದಿದ್ದೇವೆ. ನಾವು ಅದನ್ನು ಶೆಲ್ಫ್‌ನಿಂದ ತೆಗೆಯುತ್ತೇವೆ, ನಯಗೊಳಿಸಿ, ಟೈರ್‌ಗಳನ್ನು ಪಂಪ್ ಮಾಡಿ ಮತ್ತು ಒದ್ದೆಯಾದ ಬಟ್ಟೆಯಿಂದ ಒರೆಸುತ್ತೇವೆ.

ಉಬುಂಟುನ ಡೆಸ್ಕ್‌ಟಾಪ್ ಆವೃತ್ತಿಯನ್ನು ಲೆಗಸಿ ಬೂಟ್‌ಲೋಡರ್‌ನೊಂದಿಗೆ ಸರಿಯಾಗಿ ಸ್ಥಾಪಿಸಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಇಲ್ಲಿ, ಅವರು ಹೇಳಿದಂತೆ, ಕನಿಷ್ಠ ಆಯ್ಕೆಗಳಿವೆ.

ಆದ್ದರಿಂದ, ನಾವು ಯಂತ್ರಾಂಶವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ ಮತ್ತು ಉಬುಂಟು ಲೈವ್ ಬೂಟ್ ಮಾಡಬಹುದಾದ ಫ್ಲಾಶ್ ಡ್ರೈವಿನಿಂದ ಸಿಸ್ಟಮ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತೇವೆ. ನಾವು ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ನಿಮಗಾಗಿ ಕೆಲಸ ಮಾಡುವ ನೆಟ್‌ವರ್ಕ್ ಅನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ. ಇದು ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ನೀವು ಮುಂಚಿತವಾಗಿ ಫ್ಲ್ಯಾಶ್ ಡ್ರೈವಿನಲ್ಲಿ ಅಗತ್ಯ ಪ್ಯಾಕೇಜ್ಗಳನ್ನು ಲೋಡ್ ಮಾಡಬಹುದು.

ನಾವು ಡೆಸ್ಕ್‌ಟಾಪ್ ಪರಿಸರಕ್ಕೆ ಹೋಗುತ್ತೇವೆ, ಟರ್ಮಿನಲ್ ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಮತ್ತು ನಾವು ಹೋಗುತ್ತೇವೆ:

#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 ನಲ್ಲಿ ವರ್ಚುವಲ್ ಯಂತ್ರಗಳು ಅಥವಾ ಡೇಟಾಬೇಸ್‌ಗಳ ಯಾವುದೇ ಚಿತ್ರಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ.
ಈ ಎಫ್‌ಎಸ್ ಅನ್ನು ಸಿಸ್ಟಮ್‌ನ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳನ್ನು ಆಫ್ ಮಾಡದೆಯೇ ರಚಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಈ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳನ್ನು ಕಳುಹಿಸು/ಸ್ವೀಕರಿಸುವ ಮೂಲಕ ಬ್ಯಾಕಪ್ ಡಿಸ್ಕ್‌ಗೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ.

ಹೆಚ್ಚುವರಿಯಾಗಿ, ಲೇಖಕರು ಸಾಮಾನ್ಯವಾಗಿ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ಕನಿಷ್ಠ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ನೇರವಾಗಿ ಇರಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತಾರೆ ಮತ್ತು IOMMU ಮೂಲಕ KVM ಗೆ GPU ಮತ್ತು PCI-USB ಹೋಸ್ಟ್ ನಿಯಂತ್ರಕಗಳನ್ನು ಫಾರ್ವರ್ಡ್ ಮಾಡುವಂತಹ ವಿಷಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವರ್ಚುವಲ್ ಯಂತ್ರಗಳಲ್ಲಿ ಎಲ್ಲಾ ಇತರ ಸಾಫ್ಟ್‌ವೇರ್‌ಗಳನ್ನು ಚಲಾಯಿಸಲು ಬಯಸುತ್ತಾರೆ.

ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ಉಳಿದಿರುವ ವಿಷಯಗಳು ಡೇಟಾ ಸಂಗ್ರಹಣೆ, ವರ್ಚುವಲೈಸೇಶನ್ ಮತ್ತು ಬ್ಯಾಕಪ್.

ನೀವು 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 ಈ ಡ್ರೈವ್‌ಗಳನ್ನು ನೋಡುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ, ಅವರು ಸಂಪೂರ್ಣವಾಗಿ ಸಾಫ್ಟ್ವೇರ್ RAID ಗೆ ಹೋಗುತ್ತಾರೆ. ನಾವು ಅಲ್ಲಿ ವಿಭಾಗಗಳನ್ನು ಸಹ ರಚಿಸುವುದಿಲ್ಲ. ನೀವು "ಕ್ಯಾನನ್" ಅಥವಾ "ಪ್ರಧಾನವಾಗಿ" ಅನುಸರಿಸಲು ಬಯಸಿದರೆ, 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

ಸಾಟಾ ಎಸ್‌ಎಸ್‌ಡಿ

ಇಲ್ಲಿ ವಿಷಯಗಳು ನಮಗೆ ಆಸಕ್ತಿದಾಯಕವಾಗುತ್ತವೆ.

ಮೊದಲನೆಯದಾಗಿ, ನಮ್ಮ ಡ್ರೈವ್‌ಗಳು 2 TB ಗಾತ್ರದಲ್ಲಿರುತ್ತವೆ. ಇದು MBR ಗಾಗಿ ಸ್ವೀಕಾರಾರ್ಹ ವ್ಯಾಪ್ತಿಯಲ್ಲಿದೆ, ಅದನ್ನು ನಾವು ಬಳಸುತ್ತೇವೆ. ಅಗತ್ಯವಿದ್ದರೆ, GPT ಯೊಂದಿಗೆ ಬದಲಾಯಿಸಬಹುದು. GPT ಡಿಸ್ಕ್‌ಗಳು ಹೊಂದಾಣಿಕೆಯ ಪದರವನ್ನು ಹೊಂದಿದ್ದು ಅದು MBR-ಹೊಂದಾಣಿಕೆಯ ವ್ಯವಸ್ಥೆಗಳು ಮೊದಲ 4 ವಿಭಾಗಗಳನ್ನು ಮೊದಲ 2 ಟೆರಾಬೈಟ್‌ಗಳ ಒಳಗೆ ಇದ್ದರೆ ಅವುಗಳನ್ನು ನೋಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ಈ ಡಿಸ್ಕ್ಗಳಲ್ಲಿ ಬೂಟ್ ವಿಭಾಗ ಮತ್ತು ಬಯೋಸ್_ಗ್ರಬ್ ವಿಭಾಗವು ಪ್ರಾರಂಭದಲ್ಲಿರಬೇಕು. ಇದು ನಿಮಗೆ GPT ಲೆಗಸಿ/BIOS ಡ್ರೈವ್‌ಗಳಿಂದ ಬೂಟ್ ಮಾಡಲು ಸಹ ಅನುಮತಿಸುತ್ತದೆ.

ಆದರೆ ಇದು ನಮ್ಮ ಪ್ರಕರಣವಲ್ಲ.

ಇಲ್ಲಿ ನಾವು ಎರಡು ವಿಭಾಗಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ. ಮೊದಲನೆಯದು 1 GB ಗಾತ್ರದಲ್ಲಿರುತ್ತದೆ ಮತ್ತು RAID 1 /boot ಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಎರಡನೆಯದನ್ನು RAID 6 ಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಡ್ರೈವ್‌ನ ಕೊನೆಯಲ್ಲಿ ಒಂದು ಸಣ್ಣ ಹಂಚಿಕೆಯಾಗದ ಪ್ರದೇಶವನ್ನು ಹೊರತುಪಡಿಸಿ ಉಳಿದಿರುವ ಎಲ್ಲಾ ಮುಕ್ತ ಜಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ಈ ಗುರುತಿಸದ ಪ್ರದೇಶ ಯಾವುದು?ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿರುವ ಮೂಲಗಳ ಪ್ರಕಾರ, ನಮ್ಮ SATA SSD ಗಳು 6 ರಿಂದ 78 ಗಿಗಾಬೈಟ್‌ಗಳಷ್ಟು ಗಾತ್ರದಲ್ಲಿ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ವಿಸ್ತರಿಸಬಹುದಾದ SLC ಸಂಗ್ರಹವನ್ನು ಹೊಂದಿವೆ. ಡ್ರೈವ್‌ನ ಡೇಟಾ ಶೀಟ್‌ನಲ್ಲಿ "ಗಿಗಾಬೈಟ್‌ಗಳು" ಮತ್ತು "ಗಿಬಿಬೈಟ್‌ಗಳು" ನಡುವಿನ ವ್ಯತ್ಯಾಸದಿಂದಾಗಿ ನಾವು 6 ಗಿಗಾಬೈಟ್‌ಗಳನ್ನು "ಉಚಿತವಾಗಿ" ಪಡೆಯುತ್ತೇವೆ. ಉಳಿದ 72 ಗಿಗಾಬೈಟ್‌ಗಳನ್ನು ಬಳಕೆಯಾಗದ ಜಾಗದಿಂದ ಹಂಚಲಾಗುತ್ತದೆ.

ಇಲ್ಲಿ ನಾವು SLC ಸಂಗ್ರಹವನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ಜಾಗವನ್ನು 4 ಬಿಟ್ MLC ಮೋಡ್ನಲ್ಲಿ ಆಕ್ರಮಿಸಿಕೊಂಡಿದ್ದೇವೆ ಎಂದು ಗಮನಿಸಬೇಕು. ನಮಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಅರ್ಥವೆಂದರೆ ಪ್ರತಿ 4 ಗಿಗಾಬೈಟ್‌ಗಳ ಮುಕ್ತ ಜಾಗಕ್ಕೆ ನಾವು 1 ಗಿಗಾಬೈಟ್ SLC ಸಂಗ್ರಹವನ್ನು ಮಾತ್ರ ಪಡೆಯುತ್ತೇವೆ.

72 ಗಿಗಾಬೈಟ್‌ಗಳನ್ನು 4 ರಿಂದ ಗುಣಿಸಿ ಮತ್ತು 288 ಗಿಗಾಬೈಟ್‌ಗಳನ್ನು ಪಡೆಯಿರಿ. ಇದು SLC ಸಂಗ್ರಹವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಳಸಲು ಡ್ರೈವ್‌ಗಳನ್ನು ಅನುಮತಿಸುವ ಸಲುವಾಗಿ ನಾವು ಗುರುತಿಸದ ಮುಕ್ತ ಸ್ಥಳವಾಗಿದೆ.

ಹೀಗಾಗಿ, ನಾವು ಒಟ್ಟು ಆರು ಡ್ರೈವ್‌ಗಳಿಂದ 312 ಗಿಗಾಬೈಟ್‌ಗಳ SLC ಸಂಗ್ರಹವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪಡೆಯುತ್ತೇವೆ. ಎಲ್ಲಾ ಡ್ರೈವ್‌ಗಳಲ್ಲಿ, ಪುನರಾವರ್ತನೆಗಾಗಿ 2 ಅನ್ನು RAID ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಈ ಪ್ರಮಾಣದ ಸಂಗ್ರಹವು ನಿಜ ಜೀವನದಲ್ಲಿ ಬರಹವು ಸಂಗ್ರಹಕ್ಕೆ ಹೋಗದ ಪರಿಸ್ಥಿತಿಯನ್ನು ಎದುರಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಕ್ಯೂಎಲ್‌ಸಿ ಮೆಮೊರಿಯ ಅತ್ಯಂತ ದುಃಖದ ನ್ಯೂನತೆಯನ್ನು ಸರಿದೂಗಿಸುತ್ತದೆ - ಸಂಗ್ರಹವನ್ನು ಬೈಪಾಸ್ ಮಾಡುವ ಮೂಲಕ ಡೇಟಾವನ್ನು ಬರೆಯುವಾಗ ಅತ್ಯಂತ ಕಡಿಮೆ ಬರೆಯುವ ವೇಗ. ನಿಮ್ಮ ಲೋಡ್‌ಗಳು ಇದಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ, ಡೇಟಾ ಶೀಟ್‌ನಿಂದ TBW ಅನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು ನಿಮ್ಮ SSD ಅಂತಹ ಲೋಡ್‌ನಲ್ಲಿ ಎಷ್ಟು ಕಾಲ ಉಳಿಯುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ನೀವು ಕಠಿಣವಾಗಿ ಯೋಚಿಸಬೇಕೆಂದು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ.

#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 DISCARD ಅನ್ನು ಬಾಕ್ಸ್‌ನ ಹೊರಗೆ ಬೆಂಬಲಿಸಲಾಗುತ್ತದೆ.

SSD RAID 6 ಡಿಸ್ಕಾರ್ಡ್ ಅರೇಗಳಿಗಾಗಿ, ನೀವು ಅದನ್ನು ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್ ನಿಯತಾಂಕಗಳಲ್ಲಿ ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು.

ಈ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ 4/5/6 ಹಂತಗಳಲ್ಲಿ ಬಳಸಲಾದ ಎಲ್ಲಾ SSD ಗಳು discard_zeroes_data ಗಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದ್ದರೆ ಮಾತ್ರ ಇದನ್ನು ಮಾಡಬೇಕು. ಕೆಲವೊಮ್ಮೆ ಈ ಕಾರ್ಯವು ಬೆಂಬಲಿತವಾಗಿದೆ ಎಂದು ಕರ್ನಲ್‌ಗೆ ಹೇಳುವ ವಿಚಿತ್ರ ಡ್ರೈವ್‌ಗಳನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ, ಆದರೆ ವಾಸ್ತವವಾಗಿ ಅದು ಇಲ್ಲ, ಅಥವಾ ಕಾರ್ಯವು ಯಾವಾಗಲೂ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ಈ ಸಮಯದಲ್ಲಿ, ಬೆಂಬಲ ಬಹುತೇಕ ಎಲ್ಲೆಡೆ ಲಭ್ಯವಿದೆ, ಆದಾಗ್ಯೂ, ದೋಷಗಳೊಂದಿಗೆ ಹಳೆಯ ಡ್ರೈವ್ಗಳು ಮತ್ತು ಫರ್ಮ್ವೇರ್ ಇವೆ. ಈ ಕಾರಣಕ್ಕಾಗಿ, RAID 6 ಗಾಗಿ DISCARD ಬೆಂಬಲವನ್ನು ಡಿಫಾಲ್ಟ್ ಆಗಿ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ.

ಗಮನ, ಕೆಳಗಿನ ಆಜ್ಞೆಯು "ಸೊನ್ನೆಗಳೊಂದಿಗೆ" ರಚನೆಯನ್ನು "ಪ್ರಾರಂಭಿಸುವ" ಮೂಲಕ NVMe ಡ್ರೈವ್‌ಗಳಲ್ಲಿನ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ನಾಶಪಡಿಸುತ್ತದೆ.

#blkdiscard /dev/md0

ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ, ಹಂತವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಪ್ರಯತ್ನಿಸಿ.

#blkdiscard --step 65536 /dev/md0

ಸಾಟಾ ಎಸ್‌ಎಸ್‌ಡಿ

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

ಯಾಕೆ ಇಷ್ಟು ದೊಡ್ಡದು...?ಚಂಕ್-ಗಾತ್ರವನ್ನು ಹೆಚ್ಚಿಸುವುದು ಚಂಕ್-ಗಾತ್ರವನ್ನು ಒಳಗೊಂಡಂತೆ ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಓದುವಿಕೆಯ ವೇಗದ ಮೇಲೆ ಧನಾತ್ಮಕ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ. ಇದು ಸಂಭವಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಸೂಕ್ತವಾದ ಗಾತ್ರದ ಅಥವಾ ಚಿಕ್ಕದಾದ ಒಂದು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಒಂದೇ ಸಾಧನದಲ್ಲಿ ಸಂಪೂರ್ಣವಾಗಿ ಪೂರ್ಣಗೊಳಿಸಬಹುದು. ಆದ್ದರಿಂದ, ಎಲ್ಲಾ ಸಾಧನಗಳಿಂದ IOPS ಅನ್ನು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಲಾಗಿದೆ. ಅಂಕಿಅಂಶಗಳ ಪ್ರಕಾರ, 99% IO 512K ಅನ್ನು ಮೀರುವುದಿಲ್ಲ.

ಪ್ರತಿ ಬರಹಕ್ಕೆ RAID 6 IOPS ಯಾವಾಗಲೂ ಒಂದು ಡ್ರೈವ್‌ನ IOPS ಗಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮಾನವಾಗಿರುತ್ತದೆ. ಯಾವಾಗ, ಯಾದೃಚ್ಛಿಕವಾಗಿ ಓದಿದಾಗ, IOPS ಒಂದು ಡ್ರೈವ್‌ಗಿಂತ ಹಲವಾರು ಪಟ್ಟು ಹೆಚ್ಚಾಗಿರುತ್ತದೆ ಮತ್ತು ಇಲ್ಲಿ ಬ್ಲಾಕ್ ಗಾತ್ರವು ಪ್ರಮುಖ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ಹೊಂದಿದೆ.
RAID 6 ಬೈ-ಡಿಸೈನ್‌ನಲ್ಲಿ ಕೆಟ್ಟ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುವುದರಲ್ಲಿ ಲೇಖಕರಿಗೆ ಅರ್ಥವಿಲ್ಲ ಮತ್ತು ಬದಲಿಗೆ RAID 6 ಯಾವುದು ಉತ್ತಮವಾಗಿದೆ ಎಂಬುದನ್ನು ಉತ್ತಮಗೊಳಿಸುತ್ತದೆ.
RAID 6 ನ ಕಳಪೆ ಯಾದೃಚ್ಛಿಕ ಬರವಣಿಗೆಯನ್ನು NVMe ಸಂಗ್ರಹ ಮತ್ತು ಥಿನ್-ಪ್ರೊವಿಶನಿಂಗ್ ಟ್ರಿಕ್‌ಗಳೊಂದಿಗೆ ನಾವು ಸರಿದೂಗಿಸುತ್ತೇವೆ.

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

RAM ನ ಗಾತ್ರಕ್ಕೆ ಅನುಗುಣವಾಗಿ ವಿನಿಮಯಕ್ಕಾಗಿ ವಿಭಾಗವನ್ನು ರಚಿಸೋಣ.

#lvcreate -L 32G --name swap root

OS ಸ್ಥಾಪನೆ

ಒಟ್ಟಾರೆಯಾಗಿ, ಸಿಸ್ಟಮ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲವನ್ನೂ ನಾವು ಹೊಂದಿದ್ದೇವೆ.

ಉಬುಂಟು ಲೈವ್ ಪರಿಸರದಿಂದ ಸಿಸ್ಟಮ್ ಇನ್‌ಸ್ಟಾಲೇಶನ್ ವಿಝಾರ್ಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ. ಸಾಮಾನ್ಯ ಅನುಸ್ಥಾಪನೆ. ಅನುಸ್ಥಾಪನೆಗೆ ಡಿಸ್ಕ್ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಹಂತದಲ್ಲಿ ಮಾತ್ರ, ನೀವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗಿದೆ:

  • /dev/md1, - ಮೌಂಟ್ ಪಾಯಿಂಟ್ /boot, FS - BTRFS
  • /dev/root/root (aka /dev/mapper/root-root), - ಮೌಂಟ್ ಪಾಯಿಂಟ್ / (ರೂಟ್), FS - BTRFS
  • /dev/root/swap (aka /dev/mapper/root-swap), - ಸ್ವಾಪ್ ವಿಭಾಗವಾಗಿ ಬಳಸಿ
  • /dev/sda ನಲ್ಲಿ ಬೂಟ್‌ಲೋಡರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ

ನೀವು BTRFS ಅನ್ನು ರೂಟ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಆಗಿ ಆಯ್ಕೆ ಮಾಡಿದಾಗ, ಅನುಸ್ಥಾಪಕವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಎರಡು BTRFS ಸಂಪುಟಗಳನ್ನು "@" ಗಾಗಿ / (root) ಮತ್ತು "@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 /mnt/chroot

ಮೊದಲನೆಯದಾಗಿ, ನಾವು ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ವಿತರಿಸುತ್ತೇವೆ:

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

ಅಪೂರ್ಣ ಸಿಸ್ಟಮ್ ಸ್ಥಾಪನೆಯಿಂದಾಗಿ ವಕ್ರವಾಗಿ ಸ್ಥಾಪಿಸಲಾದ ಎಲ್ಲಾ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸೋಣ ಮತ್ತು ಸರಿಪಡಿಸೋಣ:

#CORRUPTED_PACKAGES=$(debsums -s 2>&1 | awk '{print $6}' | uniq)
#apt-get install --reinstall $CORRUPTED_PACKAGES

ಏನಾದರೂ ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ನೀವು ಮೊದಲು /etc/apt/sources.list ಅನ್ನು ಸಂಪಾದಿಸಬೇಕಾಗಬಹುದು

TRIM/DISCARD ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು RAID 6 ಮಾಡ್ಯೂಲ್‌ಗಾಗಿ ನಿಯತಾಂಕಗಳನ್ನು ಹೊಂದಿಸೋಣ:

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

ನಮ್ಮ ಅರೇಗಳನ್ನು ಸ್ವಲ್ಪ ತಿರುಚೋಣ:

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

ಏನಾಗಿತ್ತು..?ನಾವು udev ನಿಯಮಗಳ ಗುಂಪನ್ನು ರಚಿಸಿದ್ದೇವೆ ಅದು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮಾಡುತ್ತದೆ:

  • RAID 2020 ಗಾಗಿ ಬ್ಲಾಕ್ ಕ್ಯಾಶ್ ಗಾತ್ರವನ್ನು 6 ಕ್ಕೆ ಸಮರ್ಪಕವಾಗಿ ಹೊಂದಿಸಿ. ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವು, Linux ಅನ್ನು ರಚಿಸಿದಾಗಿನಿಂದ ಬದಲಾಗಿಲ್ಲ ಮತ್ತು ದೀರ್ಘಕಾಲದವರೆಗೆ ಸಮರ್ಪಕವಾಗಿಲ್ಲ.
  • ಅರೇ ಚೆಕ್‌ಗಳು/ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ಗಳ ಅವಧಿಗೆ ಕನಿಷ್ಠ IO ಅನ್ನು ಕಾಯ್ದಿರಿಸಿ. ನಿಮ್ಮ ಅರೇಗಳು ಲೋಡ್ ಅಡಿಯಲ್ಲಿ ಶಾಶ್ವತ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಸ್ಥಿತಿಯಲ್ಲಿ ಸಿಲುಕಿಕೊಳ್ಳುವುದನ್ನು ತಡೆಯುವುದು.
  • ಸರಣಿಗಳ ಪರಿಶೀಲನೆ/ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಸಮಯದಲ್ಲಿ ಗರಿಷ್ಠ IO ಅನ್ನು ಮಿತಿಗೊಳಿಸಿ. SSD RAID ಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವುದರಿಂದ/ಪರಿಶೀಲಿಸುವುದರಿಂದ ನಿಮ್ಮ ಡ್ರೈವ್‌ಗಳು ಗರಿಗರಿಯಾಗದಂತೆ ಇದು ಅವಶ್ಯಕವಾಗಿದೆ. NVMe ಗೆ ಇದು ವಿಶೇಷವಾಗಿ ಸತ್ಯವಾಗಿದೆ. (ರೇಡಿಯೇಟರ್ ಬಗ್ಗೆ ನೆನಪಿದೆಯೇ? ನಾನು ತಮಾಷೆ ಮಾಡಲಿಲ್ಲ.)
  • APM ಮೂಲಕ ಸ್ಪಿಂಡಲ್ ತಿರುಗುವಿಕೆಯನ್ನು (HDD) ನಿಲ್ಲಿಸುವುದರಿಂದ ಡಿಸ್ಕ್‌ಗಳನ್ನು ನಿಷೇಧಿಸಿ ಮತ್ತು ಡಿಸ್ಕ್ ನಿಯಂತ್ರಕಗಳಿಗೆ ನಿದ್ರೆಯ ಅವಧಿಯನ್ನು 7 ಗಂಟೆಗಳವರೆಗೆ ಹೊಂದಿಸಿ. ನಿಮ್ಮ ಡ್ರೈವ್‌ಗಳು ಇದನ್ನು ಮಾಡಲು ಸಾಧ್ಯವಾದರೆ ನೀವು APM ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬಹುದು (-B 255). ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯದೊಂದಿಗೆ, ಡ್ರೈವ್ಗಳು ಐದು ಸೆಕೆಂಡುಗಳ ನಂತರ ನಿಲ್ಲುತ್ತವೆ. ನಂತರ OS ಡಿಸ್ಕ್ ಸಂಗ್ರಹವನ್ನು ಮರುಹೊಂದಿಸಲು ಬಯಸುತ್ತದೆ, ಡಿಸ್ಕ್ಗಳು ​​ಮತ್ತೆ ಸ್ಪಿನ್ ಅಪ್ ಆಗುತ್ತವೆ ಮತ್ತು ಎಲ್ಲವೂ ಮತ್ತೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಡಿಸ್ಕ್ಗಳು ​​ಸೀಮಿತ ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಸ್ಪಿಂಡಲ್ ತಿರುಗುವಿಕೆಗಳನ್ನು ಹೊಂದಿವೆ. ಇಂತಹ ಸರಳ ಡೀಫಾಲ್ಟ್ ಚಕ್ರವು ಒಂದೆರಡು ವರ್ಷಗಳಲ್ಲಿ ನಿಮ್ಮ ಡಿಸ್ಕ್ಗಳನ್ನು ಸುಲಭವಾಗಿ ಕೊಲ್ಲುತ್ತದೆ. ಎಲ್ಲಾ ಡಿಸ್ಕ್‌ಗಳು ಇದರಿಂದ ಬಳಲುತ್ತಿಲ್ಲ, ಆದರೆ ನಮ್ಮದು "ಲ್ಯಾಪ್‌ಟಾಪ್", ಸೂಕ್ತವಾದ ಡೀಫಾಲ್ಟ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ, ಇದು RAID ಅನ್ನು ಮಿನಿ-MAID ನಂತೆ ಕಾಣುವಂತೆ ಮಾಡುತ್ತದೆ.
  • ಡಿಸ್ಕ್‌ಗಳಲ್ಲಿ ರೀಡ್‌ಹೆಡ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ (ತಿರುಗುವ) 1 ಮೆಗಾಬೈಟ್ - ಎರಡು ಸತತ ಬ್ಲಾಕ್‌ಗಳು/ಚಂಕ್ RAID 6
  • ಅರೇಗಳಲ್ಲಿಯೇ ಓದುವಿಕೆಯನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿ.

/etc/fstab ಸಂಪಾದಿಸೋಣ:

#cat >/etc/fstab << EOF
# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
# file-system mount-point type options dump pass
/dev/mapper/root-root / btrfs defaults,space_cache,noatime,nodiratime,discard,subvol=@ 0 1
UUID=$(blkid -o value -s UUID /dev/md1) /boot btrfs defaults,space_cache,noatime,nodiratime,discard 0 2
/dev/mapper/root-root /home btrfs defaults,space_cache,noatime,nodiratime,discard,subvol=@home 0 2
/dev/mapper/root-swap none swap sw 0 0
EOF
ಅದು ಯಾಕೆ..?ನಾವು UUID ಮೂಲಕ /boot ವಿಭಾಗವನ್ನು ಹುಡುಕುತ್ತೇವೆ. ಅರೇ ಹೆಸರಿಸುವಿಕೆಯು ಸೈದ್ಧಾಂತಿಕವಾಗಿ ಬದಲಾಗಬಹುದು.

ನಾವು ಉಳಿದ ವಿಭಾಗಗಳನ್ನು LVM ಹೆಸರುಗಳಿಂದ /dev/mapper/vg-lv ಸಂಕೇತದಲ್ಲಿ ಹುಡುಕುತ್ತೇವೆ, ಏಕೆಂದರೆ ಅವರು ವಿಭಾಗಗಳನ್ನು ಸಾಕಷ್ಟು ಅನನ್ಯವಾಗಿ ಗುರುತಿಸುತ್ತಾರೆ.

ನಾವು 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 ಸಂಪುಟಗಳನ್ನು (PV) ಹುಡುಕುವುದರಿಂದ ನಾವು LVM ಅನ್ನು ತಡೆಗಟ್ಟಿದ್ದೇವೆ:

  • LVM ಸಂಗ್ರಹವನ್ನು ಹೊಂದಿರುವ ಸಾಧನಗಳು (cdata)
  • ಸಂಗ್ರಹವನ್ನು ಬೈಪಾಸ್ ಮಾಡುವ ಮೂಲಕ LVM ಸಂಗ್ರಹವನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಗ್ರಹಿಸಲಾದ ಸಾಧನಗಳು ( _ಕೋರಿಗ್). ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕ್ಯಾಶ್ ಮಾಡಿದ ಸಾಧನವನ್ನು ಇನ್ನೂ ಸಂಗ್ರಹದ ಮೂಲಕ ಸ್ಕ್ಯಾನ್ ಮಾಡಲಾಗುತ್ತದೆ (ಕೇವಲ )
  • LVM ಸಂಗ್ರಹ ಮೆಟಾಡೇಟಾವನ್ನು ಹೊಂದಿರುವ ಸಾಧನಗಳು (cmeta)
  • ಹೆಸರಿನ ಚಿತ್ರಗಳೊಂದಿಗೆ VG ಯಲ್ಲಿನ ಎಲ್ಲಾ ಸಾಧನಗಳು. ಇಲ್ಲಿ ನಾವು ವರ್ಚುವಲ್ ಯಂತ್ರಗಳ ಡಿಸ್ಕ್ ಚಿತ್ರಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ಅತಿಥಿ OS ಗೆ ಸಂಬಂಧಿಸಿದ ಸಂಪುಟಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ಹೋಸ್ಟ್‌ನಲ್ಲಿ LVM ಅನ್ನು ನಾವು ಬಯಸುವುದಿಲ್ಲ.
  • ಬ್ಯಾಕಪ್ ಹೆಸರಿನೊಂದಿಗೆ VG ಯಲ್ಲಿನ ಎಲ್ಲಾ ಸಾಧನಗಳು. ಇಲ್ಲಿ ನಾವು ವರ್ಚುವಲ್ ಮೆಷಿನ್ ಇಮೇಜ್‌ಗಳ ಬ್ಯಾಕಪ್ ಪ್ರತಿಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ.
  • "gpv" (ಅತಿಥಿ ಭೌತಿಕ ಪರಿಮಾಣ) ನೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುವ ಎಲ್ಲಾ ಸಾಧನಗಳು

LVM VG ನಲ್ಲಿ ಮುಕ್ತ ಸ್ಥಳವನ್ನು ಮುಕ್ತಗೊಳಿಸುವಾಗ ನಾವು ತಿರಸ್ಕರಿಸುವ ಬೆಂಬಲವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿದ್ದೇವೆ. ಜಾಗರೂಕರಾಗಿರಿ. ಇದು SSD ಯಲ್ಲಿ LV ಗಳನ್ನು ಅಳಿಸಲು ಸಾಕಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಇದು ವಿಶೇಷವಾಗಿ SSD RAID 6 ಗೆ ಅನ್ವಯಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಯೋಜನೆಯ ಪ್ರಕಾರ, ನಾವು ತೆಳುವಾದ ಒದಗಿಸುವಿಕೆಯನ್ನು ಬಳಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ಇದು ನಮಗೆ ಅಡ್ಡಿಯಾಗುವುದಿಲ್ಲ.

initramfs ಚಿತ್ರವನ್ನು ನವೀಕರಿಸೋಣ:

#update-initramfs -u -k all

grub ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ:

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

ಯಾವ ಡಿಸ್ಕ್ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬೇಕು?ಎಸ್ಡಿ* ಆಗಿರುವ ಎಲ್ಲರೂ. ಯಾವುದೇ ಕೆಲಸ ಮಾಡುವ SATA ಡ್ರೈವ್ ಅಥವಾ SSD ಯಿಂದ ಸಿಸ್ಟಮ್ ಬೂಟ್ ಮಾಡಲು ಶಕ್ತವಾಗಿರಬೇಕು.

ಅವರು os-prober ಅನ್ನು ಏಕೆ ಸೇರಿಸಿದರು..?ಅತಿಯಾದ ಸ್ವಾತಂತ್ರ್ಯ ಮತ್ತು ತಮಾಷೆಯ ಕೈಗಳಿಗಾಗಿ.

RAID ಗಳಲ್ಲಿ ಒಂದು ಕ್ಷೀಣಿಸಿದ ಸ್ಥಿತಿಯಲ್ಲಿದ್ದರೆ ಅದು ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ. ಈ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ವರ್ಚುವಲ್ ಯಂತ್ರಗಳಲ್ಲಿ ಬಳಸಲಾಗುವ ವಿಭಾಗಗಳಲ್ಲಿ OS ಅನ್ನು ಹುಡುಕಲು ಇದು ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

ನಿಮಗೆ ಅಗತ್ಯವಿದ್ದರೆ, ನೀವು ಅದನ್ನು ಬಿಡಬಹುದು, ಆದರೆ ಮೇಲಿನ ಎಲ್ಲವನ್ನೂ ನೆನಪಿನಲ್ಲಿಡಿ. ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ನಾಟಿ ಕೈಗಳನ್ನು ತೊಡೆದುಹಾಕಲು ಪಾಕವಿಧಾನಗಳನ್ನು ಹುಡುಕಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ.

ಇದರೊಂದಿಗೆ ನಾವು ಆರಂಭಿಕ ಅನುಸ್ಥಾಪನೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ್ದೇವೆ. ಹೊಸದಾಗಿ ಸ್ಥಾಪಿಸಲಾದ OS ಗೆ ರೀಬೂಟ್ ಮಾಡುವ ಸಮಯ ಇದು. ಬೂಟ್ ಮಾಡಬಹುದಾದ ಲೈವ್ CD/USB ಅನ್ನು ತೆಗೆದುಹಾಕಲು ಮರೆಯಬೇಡಿ.

#exit
#reboot

ಯಾವುದೇ SATA SSD ಗಳನ್ನು ಬೂಟ್ ಸಾಧನವಾಗಿ ಆಯ್ಕೆಮಾಡಿ.

SATA SSD ನಲ್ಲಿ LVM

ಈ ಹಂತದಲ್ಲಿ, ನಾವು ಈಗಾಗಲೇ ಹೊಸ OS ಗೆ ಬೂಟ್ ಮಾಡಿದ್ದೇವೆ, ನೆಟ್‌ವರ್ಕ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದೇವೆ, ಸೂಕ್ತವಾಗಿ, ಟರ್ಮಿನಲ್ ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ತೆರೆದಿದ್ದೇವೆ ಮತ್ತು ರನ್ ಮಾಡಿದ್ದೇವೆ:

#sudo bash

ಮುಂದುವರೆಸೋಣ.

SATA SSD ಯಿಂದ ರಚನೆಯನ್ನು "ಪ್ರಾರಂಭಿಸಿ":

#blkdiscard /dev/md2

ಅದು ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ನಂತರ ಪ್ರಯತ್ನಿಸಿ:

#blkdiscard --step 65536 /dev/md2
SATA SSD ನಲ್ಲಿ LVM VG ಅನ್ನು ರಚಿಸಿ:

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

ಮತ್ತೇಕೆ ವಿಜಿ..?ವಾಸ್ತವವಾಗಿ, ನಾವು ಈಗಾಗಲೇ ರೂಟ್ ಹೆಸರಿನ VG ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಎಲ್ಲವನ್ನೂ ಒಂದೇ ವಿಜಿಗೆ ಏಕೆ ಸೇರಿಸಬಾರದು?

VG ಯಲ್ಲಿ ಹಲವಾರು PV ಗಳಿದ್ದರೆ, VG ಅನ್ನು ಸರಿಯಾಗಿ ಸಕ್ರಿಯಗೊಳಿಸಲು, ಎಲ್ಲಾ PV ಗಳು (ಆನ್‌ಲೈನ್) ಇರಬೇಕು. ವಿನಾಯಿತಿಯು LVM RAID ಆಗಿದೆ, ನಾವು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಬಳಸುವುದಿಲ್ಲ.

ಯಾವುದೇ RAID 6 ಅರೇಗಳಲ್ಲಿ ವಿಫಲವಾದರೆ (ಡೇಟಾ ನಷ್ಟವನ್ನು ಓದಿ) ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಸಾಮಾನ್ಯವಾಗಿ ಬೂಟ್ ಆಗುತ್ತದೆ ಮತ್ತು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನಮಗೆ ಅವಕಾಶವನ್ನು ನೀಡುತ್ತದೆ ಎಂದು ನಾವು ನಿಜವಾಗಿಯೂ ಬಯಸುತ್ತೇವೆ.

ಇದನ್ನು ಮಾಡಲು, ಅಮೂರ್ತತೆಯ ಮೊದಲ ಹಂತದಲ್ಲಿ ನಾವು ಪ್ರತಿಯೊಂದು ರೀತಿಯ ಭೌತಿಕ "ಮಾಧ್ಯಮ" ವನ್ನು ಪ್ರತ್ಯೇಕ ವಿಜಿಗೆ ಪ್ರತ್ಯೇಕಿಸುತ್ತೇವೆ.

ವೈಜ್ಞಾನಿಕವಾಗಿ ಹೇಳುವುದಾದರೆ, ವಿಭಿನ್ನ RAID ಅರೇಗಳು ವಿಭಿನ್ನ "ವಿಶ್ವಾಸಾರ್ಹ ಡೊಮೇನ್‌ಗಳಿಗೆ" ಸೇರಿರುತ್ತವೆ. ನೀವು ಅವುಗಳನ್ನು ಒಂದು ವಿಜಿಗೆ ಕ್ರ್ಯಾಮ್ ಮಾಡುವ ಮೂಲಕ ವೈಫಲ್ಯದ ಹೆಚ್ಚುವರಿ ಸಾಮಾನ್ಯ ಬಿಂದುವನ್ನು ರಚಿಸಬಾರದು.

"ಹಾರ್ಡ್‌ವೇರ್" ಮಟ್ಟದಲ್ಲಿ 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 SSD ಗಳು ಸಂಗ್ರಹದೊಂದಿಗೆ ನಮ್ಮ 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 ಥಿನ್ ಬ್ಲಾಕ್‌ನ ಗಾತ್ರದೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾದರೆ ಉತ್ತಮ ಫಲಿತಾಂಶವನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ ಎಂದು ಲೇಖಕರು ಕಂಡುಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಯಿತು. ಇದಲ್ಲದೆ, ಸಣ್ಣ ಗಾತ್ರ, ಉತ್ತಮವಾದ ಸಂರಚನೆಯು ಯಾದೃಚ್ಛಿಕ ರೆಕಾರ್ಡಿಂಗ್ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

64k ಎಂಬುದು LVM ಥಿನ್‌ಗೆ ಅನುಮತಿಸಲಾದ ಕನಿಷ್ಟ ಬ್ಲಾಕ್ ಗಾತ್ರವಾಗಿದೆ.

ಎಚ್ಚರಿಕೆಯಿಂದ ಬರೆಯಿರಿ..!ಹೌದು. ಈ ರೀತಿಯ ಸಂಗ್ರಹವು ಕ್ಯಾಶ್ ಮಾಡಿದ ಸಾಧನಕ್ಕೆ ಬರೆಯುವ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅನ್ನು ಮುಂದೂಡುತ್ತದೆ. ಇದರರ್ಥ ಸಂಗ್ರಹವು ಕಳೆದುಹೋದರೆ, ನೀವು ಸಂಗ್ರಹಿಸಿದ ಸಾಧನದಲ್ಲಿನ ಡೇಟಾವನ್ನು ಕಳೆದುಕೊಳ್ಳಬಹುದು. ನಂತರ, ಈ ಅಪಾಯವನ್ನು ಸರಿದೂಗಿಸಲು NVMe RAID 1 ರ ಜೊತೆಗೆ ಯಾವ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಎಂಬುದನ್ನು ಲೇಖಕರು ನಿಮಗೆ ತಿಳಿಸುತ್ತಾರೆ.

RAID 6 ರ ಕಳಪೆ ಯಾದೃಚ್ಛಿಕ ಬರವಣಿಗೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸರಿದೂಗಿಸಲು ಈ ಸಂಗ್ರಹ ಪ್ರಕಾರವನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ.

ನಮಗೆ ಸಿಕ್ಕಿರುವುದನ್ನು ಪರಿಶೀಲಿಸೋಣ:

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

ಕೇವಲ [cachedata_corig] ಮಾತ್ರ /dev/data/cache ನಲ್ಲಿ ನೆಲೆಗೊಂಡಿರಬೇಕು. ಏನಾದರೂ ತಪ್ಪಾಗಿದ್ದರೆ, pvmove ಬಳಸಿ.

ಒಂದು ಆಜ್ಞೆಯೊಂದಿಗೆ ಅಗತ್ಯವಿದ್ದರೆ ನೀವು ಸಂಗ್ರಹವನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬಹುದು:

#lvconvert -y --uncache cache/cachedata

ಇದನ್ನು ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ. LVM ಕ್ಯಾಶ್ ಅನ್ನು ಡಿಸ್ಕ್‌ಗೆ ಸರಳವಾಗಿ ಸಿಂಕ್ ಮಾಡುತ್ತದೆ, ಅದನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಕ್ಯಾಶೆಡೇಟಾ_ಕೊರಿಗ್ ಅನ್ನು ಕ್ಯಾಶೆಡೇಟಾಗೆ ಮರುಹೆಸರಿಸಿ.

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 ತೆಳುವಾದ ಆಂತರಿಕ ವಿನ್ಯಾಸದಿಂದಾಗಿ, ಸಂಗ್ರಹ ನಷ್ಟದ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ನ ಸಮಗ್ರತೆಯನ್ನು ಖಾತರಿಪಡಿಸಲಾಗುತ್ತದೆ. .

ನಾವು ಹೊಸ ವಿಜಿಯನ್ನು ರಚಿಸೋಣ ಅದು ತೆಳು-ಒದಗಿಸಲು ಕಾರಣವಾಗಿದೆ:

#pvcreate /dev/root/images
#pvcreate /dev/cache/cachedata
#vgcreate images /dev/root/images /dev/cache/cachedata
ಪೂಲ್ ಅನ್ನು ರಚಿಸೋಣ:

#lvcreate -L 274877906944B --poolmetadataspare y --poolmetadatasize 4294967296B --chunksize 64k -Z y -T images/thin-pool
ಏಕೆ -Z ವೈಈ ಮೋಡ್ ನಿಜವಾಗಿ ಉದ್ದೇಶಿಸಿರುವ ಜೊತೆಗೆ - ಜಾಗವನ್ನು ಮರುಹಂಚಿಕೆ ಮಾಡುವಾಗ ಒಂದು ವರ್ಚುವಲ್ ಗಣಕದಿಂದ ಮತ್ತೊಂದು ವರ್ಚುವಲ್ ಯಂತ್ರಕ್ಕೆ ಸೋರಿಕೆಯಾಗುವುದನ್ನು ತಡೆಯಲು - 64k ಗಿಂತ ಚಿಕ್ಕದಾದ ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಬರವಣಿಗೆಯ ವೇಗವನ್ನು ಹೆಚ್ಚಿಸಲು ಝೀರೋಯಿಂಗ್ ಅನ್ನು ಹೆಚ್ಚುವರಿಯಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ತೆಳುವಾದ ಪರಿಮಾಣದ ಹಿಂದೆ ಹಂಚಿಕೆ ಮಾಡದ ಪ್ರದೇಶಕ್ಕೆ ಯಾವುದೇ 64k ಗಿಂತ ಕಡಿಮೆ ಬರೆಯುವಿಕೆಯು ಸಂಗ್ರಹದಲ್ಲಿ 64K ಅಂಚಿನ-ಜೋಡಣೆಯಾಗುತ್ತದೆ. ಕ್ಯಾಶ್ ಮಾಡಿದ ಸಾಧನವನ್ನು ಬೈಪಾಸ್ ಮಾಡುವ ಮೂಲಕ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಕ್ಯಾಶ್ ಮೂಲಕ ನಿರ್ವಹಿಸಲು ಇದು ಅನುಮತಿಸುತ್ತದೆ.

LV ಗಳನ್ನು ಅನುಗುಣವಾದ PV ಗಳಿಗೆ ಸರಿಸೋಣ:

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

ಪರಿಶೀಲಿಸೋಣ:

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

ಪರೀಕ್ಷೆಗಳಿಗಾಗಿ ತೆಳುವಾದ ಪರಿಮಾಣವನ್ನು ರಚಿಸೋಣ:

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

ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆಗಾಗಿ ನಾವು ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ:

#apt-get install sysstat fio

ನೈಜ ಸಮಯದಲ್ಲಿ ನಮ್ಮ ಶೇಖರಣಾ ಸಂರಚನೆಯ ನಡವಳಿಕೆಯನ್ನು ನೀವು ಹೇಗೆ ಗಮನಿಸಬಹುದು:

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

ನಮ್ಮ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ನಾವು ಹೇಗೆ ಪರೀಕ್ಷಿಸಬಹುದು:

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

ಎಚ್ಚರಿಕೆಯಿಂದ! ಸಂಪನ್ಮೂಲ!ಈ ಕೋಡ್ 36 ವಿಭಿನ್ನ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ 4 ಸೆಕೆಂಡುಗಳವರೆಗೆ ರನ್ ಆಗುತ್ತದೆ. ಅರ್ಧದಷ್ಟು ಪರೀಕ್ಷೆಗಳು ರೆಕಾರ್ಡಿಂಗ್ಗಾಗಿವೆ. ನೀವು 4 ಸೆಕೆಂಡುಗಳಲ್ಲಿ NVMe ನಲ್ಲಿ ಬಹಳಷ್ಟು ರೆಕಾರ್ಡ್ ಮಾಡಬಹುದು. ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ 3 ಗಿಗಾಬೈಟ್‌ಗಳವರೆಗೆ. ಆದ್ದರಿಂದ, ಬರವಣಿಗೆಯ ಪರೀಕ್ಷೆಗಳ ಪ್ರತಿ ರನ್ ನಿಮ್ಮಿಂದ 216 ಗಿಗಾಬೈಟ್ SSD ಸಂಪನ್ಮೂಲವನ್ನು ತಿನ್ನಬಹುದು.

ಓದುವುದು ಮತ್ತು ಬರೆಯುವುದು ಮಿಶ್ರಿತ?ಹೌದು. ಓದುವ ಮತ್ತು ಬರೆಯುವ ಪರೀಕ್ಷೆಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ನಡೆಸುವುದು ಅರ್ಥಪೂರ್ಣವಾಗಿದೆ. ಇದಲ್ಲದೆ, ಎಲ್ಲಾ ಸಂಗ್ರಹಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ಅರ್ಥಪೂರ್ಣವಾಗಿದೆ ಆದ್ದರಿಂದ ಹಿಂದೆ ಮಾಡಿದ ಬರಹವು ಓದುವಿಕೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.

ಮೊದಲ ಉಡಾವಣೆಯ ಸಮಯದಲ್ಲಿ ಮತ್ತು ನಂತರದ ಫಲಿತಾಂಶಗಳು ಸಂಗ್ರಹ ಮತ್ತು ತೆಳುವಾದ ವಾಲ್ಯೂಮ್ ತುಂಬಿದಂತೆ ಹೆಚ್ಚು ಬದಲಾಗುತ್ತವೆ ಮತ್ತು ಕೊನೆಯ ಉಡಾವಣೆಯ ಸಮಯದಲ್ಲಿ ತುಂಬಿದ ಕ್ಯಾಶ್‌ಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ಸಿಸ್ಟಮ್ ನಿರ್ವಹಿಸುತ್ತಿದೆಯೇ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ.

ಇತರ ವಿಷಯಗಳ ಜೊತೆಗೆ, ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳಲಾದ ಈಗಾಗಲೇ ಪೂರ್ಣ ತೆಳುವಾದ ಪರಿಮಾಣದಲ್ಲಿ ವೇಗವನ್ನು ಅಳೆಯಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. ಮೊದಲ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ರಚಿಸಿದ ನಂತರ ಯಾದೃಚ್ಛಿಕ ಬರಹಗಳು ಹೇಗೆ ತೀವ್ರವಾಗಿ ವೇಗವನ್ನು ಪಡೆಯುತ್ತವೆ ಎಂಬುದನ್ನು ವೀಕ್ಷಿಸಲು ಲೇಖಕರಿಗೆ ಅವಕಾಶವಿದೆ, ವಿಶೇಷವಾಗಿ ಸಂಗ್ರಹವು ಇನ್ನೂ ಸಂಪೂರ್ಣವಾಗಿ ತುಂಬಿಲ್ಲ. ಕಾಪಿ-ಆನ್-ರೈಟ್ ರೈಟ್ ಸೆಮ್ಯಾಂಟಿಕ್ಸ್, ಕ್ಯಾಶ್ ಮತ್ತು ಥಿನ್ ವಾಲ್ಯೂಮ್ ಬ್ಲಾಕ್‌ಗಳ ಜೋಡಣೆ, ಮತ್ತು RAID 6 ಗೆ ಯಾದೃಚ್ಛಿಕ ಬರಹವು RAID 6 ರಿಂದ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಓದುವಿಕೆಗೆ ತಿರುಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಸಂಗ್ರಹಕ್ಕೆ ಬರೆಯಲಾಗುತ್ತದೆ. ನಮ್ಮ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ, RAID 6 ರಿಂದ ಯಾದೃಚ್ಛಿಕ ಓದುವಿಕೆ ಬರವಣಿಗೆಗಿಂತ 6 ಪಟ್ಟು (ಅರೇಯಲ್ಲಿರುವ SATA SSD ಗಳ ಸಂಖ್ಯೆ) ವೇಗವಾಗಿರುತ್ತದೆ. ಏಕೆಂದರೆ CW ಗಾಗಿ ಬ್ಲಾಕ್ಗಳನ್ನು ತೆಳುವಾದ ಕೊಳದಿಂದ ಅನುಕ್ರಮವಾಗಿ ಹಂಚಲಾಗುತ್ತದೆ, ನಂತರ ರೆಕಾರ್ಡಿಂಗ್, ಬಹುಪಾಲು, ಅನುಕ್ರಮವಾಗಿ ಬದಲಾಗುತ್ತದೆ.

ಈ ಎರಡೂ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನಿಮ್ಮ ಅನುಕೂಲಕ್ಕಾಗಿ ಬಳಸಬಹುದು.

ಸಂಗ್ರಹ "ಸುಸಂಬದ್ಧ" ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳು

ಸಂಗ್ರಹ ಹಾನಿ/ನಷ್ಟದ ಸಂದರ್ಭದಲ್ಲಿ ಡೇಟಾ ನಷ್ಟದ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅವುಗಳ ಸಮಗ್ರತೆಯನ್ನು ಖಾತರಿಪಡಿಸಲು ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳನ್ನು ತಿರುಗಿಸುವ ಅಭ್ಯಾಸವನ್ನು ಪರಿಚಯಿಸಲು ಲೇಖಕರು ಪ್ರಸ್ತಾಪಿಸುತ್ತಾರೆ.

ಮೊದಲನೆಯದಾಗಿ, ಥಿನ್ ವಾಲ್ಯೂಮ್ ಮೆಟಾಡೇಟಾ ಕ್ಯಾಶ್ ಮಾಡದ ಸಾಧನದಲ್ಲಿ ನೆಲೆಸಿರುವ ಕಾರಣ, ಮೆಟಾಡೇಟಾ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ ಮತ್ತು ಸಂಭವನೀಯ ನಷ್ಟಗಳನ್ನು ಡೇಟಾ ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಪ್ರತ್ಯೇಕಿಸಲಾಗುತ್ತದೆ.

ಕೆಳಗಿನ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ತಿರುಗುವಿಕೆಯ ಚಕ್ರವು ಸಂಗ್ರಹ ನಷ್ಟದ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳೊಳಗಿನ ಡೇಟಾದ ಸಮಗ್ರತೆಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ:

  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 SSD ಗಳು 100% ಬರವಣಿಗೆ ಲೋಡ್‌ನಲ್ಲಿ ಸಂಪನ್ಮೂಲವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಖಾಲಿ ಮಾಡುತ್ತದೆ 3-4 ದಿನಗಳು. SATA SSD ಗಳು ಕೇವಲ ಎರಡು ಪಟ್ಟು ಹೆಚ್ಚು ಕಾಲ ಉಳಿಯುತ್ತವೆ. ಆದ್ದರಿಂದ, ಹೆಚ್ಚಿನ ಲೋಡ್ ಓದುವಿಕೆಗೆ ಹೋಗುತ್ತದೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ ಮತ್ತು ನಾವು ಬರೆಯಲು ಸರಾಸರಿ ಕಡಿಮೆ ಹೊರೆಯೊಂದಿಗೆ ಅತಿ ಹೆಚ್ಚು ಚಟುವಟಿಕೆಯ ತುಲನಾತ್ಮಕವಾಗಿ ಅಲ್ಪಾವಧಿಯ ಸ್ಫೋಟಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ.
  4. ನಾವು ಸೊನ್ನೆಯನ್ನು ಹಿಡಿದ (ಅಥವಾ ಮಾಡಿದ) ತಕ್ಷಣ, ನಾವು <name>.cached ಅನ್ನು <name>.committed ಎಂದು ಮರುಹೆಸರಿಸುತ್ತೇವೆ. ಹಳೆಯ <name>.committed ಅನ್ನು ಅಳಿಸಲಾಗಿದೆ.
  5. ಐಚ್ಛಿಕವಾಗಿ, ಸಂಗ್ರಹವು 100% ತುಂಬಿದ್ದರೆ, ಅದನ್ನು ಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲಕ ಮರುಸೃಷ್ಟಿಸಬಹುದು, ಹೀಗಾಗಿ ಅದನ್ನು ತೆರವುಗೊಳಿಸಬಹುದು. ಅರ್ಧ-ಖಾಲಿ ಸಂಗ್ರಹದೊಂದಿಗೆ, ಬರೆಯುವಾಗ ಸಿಸ್ಟಮ್ ಹೆಚ್ಚು ವೇಗವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
  6. ವಲಸೆಯ ಮಿತಿಯನ್ನು ಶೂನ್ಯಕ್ಕೆ ಹೊಂದಿಸಿ: #lvchange --quiet --cachesettings "migration_threshold=0" cache/cachedata ಇದು ತಾತ್ಕಾಲಿಕವಾಗಿ ಸಂಗ್ರಹವನ್ನು ಮುಖ್ಯ ಮಾಧ್ಯಮಕ್ಕೆ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವುದನ್ನು ತಡೆಯುತ್ತದೆ.
  7. ಸಂಗ್ರಹದಲ್ಲಿ ಸಾಕಷ್ಟು ಬದಲಾವಣೆಗಳು ಸಂಗ್ರಹವಾಗುವವರೆಗೆ ನಾವು ಕಾಯುತ್ತೇವೆ #lvs --rows --reportformat basic --quiet -ocache_dirty_blocks cache/cachedata | awk '{print $2}' ಅಥವಾ ಟೈಮರ್ ಆಫ್ ಆಗುತ್ತದೆ.
  8. ನಾವು ಮತ್ತೆ ಪುನರಾವರ್ತಿಸುತ್ತೇವೆ.

ವಲಸೆಯ ಮಿತಿಯಲ್ಲಿ ಏಕೆ ತೊಂದರೆಗಳು...?ವಿಷಯವೆಂದರೆ ನಿಜವಾದ ಆಚರಣೆಯಲ್ಲಿ, "ಯಾದೃಚ್ಛಿಕ" ರೆಕಾರ್ಡಿಂಗ್ ವಾಸ್ತವವಾಗಿ ಸಂಪೂರ್ಣವಾಗಿ ಯಾದೃಚ್ಛಿಕವಾಗಿಲ್ಲ. ನಾವು 4 ಕಿಲೋಬೈಟ್‌ಗಳ ಗಾತ್ರದ ಸೆಕ್ಟರ್‌ಗೆ ಏನನ್ನಾದರೂ ಬರೆದರೆ, ಮುಂದಿನ ಒಂದೆರಡು ನಿಮಿಷಗಳಲ್ಲಿ ಅದೇ ಅಥವಾ ನೆರೆಯ (+- 32K) ಸೆಕ್ಟರ್‌ಗಳಲ್ಲಿ ಒಂದಕ್ಕೆ ದಾಖಲೆಯನ್ನು ಮಾಡುವ ಹೆಚ್ಚಿನ ಸಂಭವನೀಯತೆಯಿದೆ.

ವಲಸೆಯ ಮಿತಿಯನ್ನು ಶೂನ್ಯಕ್ಕೆ ಹೊಂದಿಸುವ ಮೂಲಕ, ನಾವು SATA SSD ನಲ್ಲಿ ಬರೆಯುವ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅನ್ನು ಮುಂದೂಡುತ್ತೇವೆ ಮತ್ತು ಸಂಗ್ರಹದಲ್ಲಿನ ಒಂದು 64K ಬ್ಲಾಕ್‌ಗೆ ಹಲವಾರು ಬದಲಾವಣೆಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸುತ್ತೇವೆ. ಇದು SATA SSD ಯ ಸಂಪನ್ಮೂಲವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಉಳಿಸುತ್ತದೆ.

ಕೋಡ್ ಎಲ್ಲಿದೆ..?ದುರದೃಷ್ಟವಶಾತ್, ಲೇಖಕರು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಸಾಕಷ್ಟು ಸಮರ್ಥರಲ್ಲ ಎಂದು ಪರಿಗಣಿಸುತ್ತಾರೆ ಏಕೆಂದರೆ ಅವರು 100% ಸ್ವಯಂ-ಕಲಿತ ಮತ್ತು "ಗೂಗಲ್" ಚಾಲಿತ ಅಭಿವೃದ್ಧಿಯನ್ನು ಅಭ್ಯಾಸ ಮಾಡುತ್ತಾರೆ, ಆದ್ದರಿಂದ ಅವರ ಕೈಯಿಂದ ಹೊರಬರುವ ಭಯಾನಕ ಕೋಡ್ ಅನ್ನು ಯಾರೂ ಬಳಸಬಾರದು ಎಂದು ಅವರು ನಂಬುತ್ತಾರೆ. ಬೇರೆ.

ಈ ಕ್ಷೇತ್ರದ ವೃತ್ತಿಪರರು ಅಗತ್ಯವಿದ್ದಲ್ಲಿ, ಮೇಲೆ ವಿವರಿಸಿದ ಎಲ್ಲಾ ತರ್ಕಗಳನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಚಿತ್ರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಮತ್ತು ಬಹುಶಃ, ಲೇಖಕರು ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದಂತೆ ಅದನ್ನು ಸಿಸ್ಟಮ್ಡ್ ಸೇವೆಯಾಗಿ ಸುಂದರವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಬಹುದು.

ಅಂತಹ ಸರಳ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ತಿರುಗುವಿಕೆಯ ಯೋಜನೆಯು SATA SSD ಯಲ್ಲಿ ನಿರಂತರವಾಗಿ ಒಂದು ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಥಿನ್_ಡೆಲ್ಟಾ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ಅದರ ರಚನೆಯ ನಂತರ ಯಾವ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಲು ಮತ್ತು ಹಾನಿಯನ್ನು ಸ್ಥಳೀಕರಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಮುಖ್ಯ ಸಂಪುಟಗಳು, ಚೇತರಿಕೆಯನ್ನು ಹೆಚ್ಚು ಸರಳಗೊಳಿಸುತ್ತದೆ.

libvirt/KVM ನಲ್ಲಿ TRIM/DISCARD

ಏಕೆಂದರೆ ಡೇಟಾ ಸಂಗ್ರಹಣೆಯನ್ನು KVM ಚಾಲನೆಯಲ್ಲಿರುವ libvirt ಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ನಂತರ ನಮ್ಮ VM ಗಳಿಗೆ ಮುಕ್ತ ಸ್ಥಳವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಮಾತ್ರವಲ್ಲ, ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿರುವುದನ್ನು ಮುಕ್ತಗೊಳಿಸಲು ಕಲಿಸುವುದು ಒಳ್ಳೆಯದು.

ವರ್ಚುವಲ್ ಡಿಸ್ಕ್‌ಗಳಲ್ಲಿ TRIM/DISCARD ಬೆಂಬಲವನ್ನು ಅನುಕರಿಸುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ನೀವು ನಿಯಂತ್ರಕ ಪ್ರಕಾರವನ್ನು virtio-scsi ಗೆ ಬದಲಾಯಿಸಬೇಕು ಮತ್ತು xml ಅನ್ನು ಸಂಪಾದಿಸಬೇಕು.

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

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

ಅತಿಥಿ 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

ಅದು ಏನು ಮಾಡುತ್ತದೆ...?ತೆಳುವಾದ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳನ್ನು ಮ್ಯಾನಿಪುಲೇಟ್ ಮಾಡಲು ಮತ್ತು ddrescue ಮತ್ತು blkdiscard ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮತ್ತೊಂದು ಬ್ಲಾಕ್ ಸಾಧನಕ್ಕೆ thin_delta ಮೂಲಕ ಸ್ವೀಕರಿಸಿದ ಎರಡು ತೆಳುವಾದ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ಆಜ್ಞೆಗಳ ಗುಂಪನ್ನು ಒಳಗೊಂಡಿದೆ.

ನಾವು ಕ್ರಾನ್‌ನಲ್ಲಿ ಹಾಕುವ ಇನ್ನೊಂದು ಸ್ಕ್ರಿಪ್ಟ್:

ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಬಾಷ್#cat >/root/lvm-thin-backup/cron-daily.sh << EOF
#!/bin/bash
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

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

BACKUP_SCRIPT="$SCRIPT_DIR/lvm-thin-backup.sh"
RETENTION="-60 days"

$BACKUP_SCRIPT backup images linux-dev
$BACKUP_SCRIPT backup images win8
$BACKUP_SCRIPT backup images win8-data
#etc

$BACKUP_SCRIPT removeall images linux-dev "$RETENTION"
$BACKUP_SCRIPT removeall images win8 "$RETENTION"
$BACKUP_SCRIPT removeall images win8-data "$RETENTION"
#etc

EOF

ಅದು ಏನು ಮಾಡುತ್ತದೆ...?ಪಟ್ಟಿ ಮಾಡಲಾದ ತೆಳುವಾದ ಸಂಪುಟಗಳ ಬ್ಯಾಕ್‌ಅಪ್‌ಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ಹಿಂದಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್ ಪಟ್ಟಿ ಮಾಡಲಾದ ಸಂಪುಟಗಳ ನಿಷ್ಕ್ರಿಯ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳನ್ನು ಬಿಡುತ್ತದೆ, ಇದು ಕೊನೆಯ ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ನಿಂದ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಅಗತ್ಯವಿದೆ.

ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸಂಪಾದಿಸಬೇಕು, ಬ್ಯಾಕಪ್ ಪ್ರತಿಗಳನ್ನು ಮಾಡಬೇಕಾದ ತೆಳುವಾದ ಸಂಪುಟಗಳ ಪಟ್ಟಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು. ನೀಡಿರುವ ಹೆಸರುಗಳು ವಿವರಣಾತ್ಮಕ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಮಾತ್ರ. ನೀವು ಬಯಸಿದರೆ, ನೀವು ಎಲ್ಲಾ ಸಂಪುಟಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯಬಹುದು.

ಹಕ್ಕುಗಳನ್ನು ನೀಡೋಣ:

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

ಅದನ್ನು ಪರಿಶೀಲಿಸೋಣ ಮತ್ತು ಅದನ್ನು ಕ್ರಾನ್‌ನಲ್ಲಿ ಇಡೋಣ:

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

ಮೊದಲ ಉಡಾವಣೆ ದೀರ್ಘವಾಗಿರುತ್ತದೆ, ಏಕೆಂದರೆ... ಬಳಸಿದ ಎಲ್ಲಾ ಜಾಗವನ್ನು ನಕಲಿಸುವ ಮೂಲಕ ತೆಳುವಾದ ಸಂಪುಟಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲಾಗುತ್ತದೆ. 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 ತೀವ್ರ ನಮ್ಯತೆಯನ್ನು ನೀಡುತ್ತದೆ.

ಪಿಎಸ್

ಮುಂದಿನ ಲೇಖನದಲ್ಲಿ, ಹೋಮ್ ಡೆಸ್ಕ್‌ಟಾಪ್‌ಗಳು, ಹೋಮ್ ಇಂಟರ್ನೆಟ್ ಮತ್ತು P2P ನೆಟ್‌ವರ್ಕ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹಲವಾರು ಖಂಡಗಳಲ್ಲಿ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ ಜಿಯೋ-ಡಿಸ್ಟ್ರಿಬ್ಯೂಟೆಡ್ ಸ್ಟೋರೇಜ್/ವಿಎಂ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ರಚಿಸಲು ನಾವು ಹಲವಾರು ರೀತಿಯ ಮೊಬೈಲ್ ಸ್ಟೋರೇಜ್ ಸಿಸ್ಟಮ್‌ಗಳು/ಕೆವಿಎಂ ಅನ್ನು ಆಧಾರವಾಗಿ ಬಳಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ.

ಮೂಲ: www.habr.com

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ