Käerz Zäit.
Ech wéilt mat der Gemeinschaft meng praktesch Erfahrung deelen fir en Datelagerungssystem fir KVM mat md RAID + LVM ze bauen.
De Programm wäert enthalen:
- Bauen md RAID 1 vun NVMe SSD.
- Assemblée md RAID 6 vun SATA SSD a regelméisseg fiert.
- Features vun TRIM / DISCARD Operatioun op SSD RAID 1/6.
- Erstellt e bootbar md RAID 1/6 Array op engem gemeinsame Set vu Disken.
- Installéiert de System op NVMe RAID 1 wann et keng NVMe Ënnerstëtzung am BIOS gëtt.
- Benotzt LVM Cache an LVM dënn.
- Benotzt BTRFS Schnappschëss a schéckt / kréien fir Backup.
- Benotzt LVM dënn Snapshots an thin_delta fir BTRFS-Stil Backups.
Wann Dir interesséiert sidd, kuckt w.e.g. Kaz.
Ufro uginn
Den Auteur dréit keng Verantwortung fir d'Konsequenze vu Materialien / Beispiller / Code / Tipps / Daten aus dësem Artikel ze benotzen oder net. Andeems Dir dëst Material op iergendeng Manéier liest oder benotzt, iwwerhëlt Dir Verantwortung fir all Konsequenze vun dësen Aktiounen. Méiglech Konsequenzen enthalen:
- Crisp-frittéiert NVMe SSDs.
- Komplett benotzt Opnamressource an Ausfall vun SSD Drive.
- Komplett Verloscht vun all Daten op all fiert, dorënner Backupsatellit Kopie.
- Defekt Computer Hardware.
- Verschwenden Zäit, Nerven a Suen.
- All aner Konsequenzen déi net uewen opgezielt sinn.
Iron
Verfügbar waren:
Motherboard aus ronn 2013 mat Z87 chipset, komplett mat Intel Haaptentwéckler i7 / Haswell.
- Prozessor 4 Kär, 8 thread
- 32 GB DDR3 RAM
- 1 x 16 oder 2 x 8 PCIe 3.0
- 1 x 4 + 1 x 1 PCIe 2.0
- 6 x 6 GBps SATA 3 Stecker
SAS Adapter LSI SAS9211-8I blénkt op IT / HBA Modus. RAID-aktivéiert Firmware gouf bewosst duerch HBA Firmware ersat fir:
- Dir kënnt dësen Adapter zu all Moment erauswerfen an ersetzen mat engem aneren deen Dir begéint hutt.
- TRIM / Discard funktionnéiert normalerweis op Disken, well ... an RAID Firmware sinn dës Kommandoen guer net ënnerstëtzt, an der HBA, am Allgemengen, egal wat Kommandoen iwwer de Bus iwwerdroen ginn.
Festplacken - 8 Stéck HGST Travelstar 7K1000 mat enger Kapazitéit vun 1 TB an engem 2.5 Formfaktor, wéi fir Laptops. Dës Fuere ware virdru an engem RAID 6 Array. Si wäerten och e Gebrauch am neie System hunn. Fir lokal Backups ze späicheren.
Zousätzlech dobäigesat:
6 Stécker SATA SSD Modell Samsung 860 QVO 2TB. Dës SSDs erfuerderen e grousst Volumen, d'Präsenz vun engem SLC Cache, Zouverlässegkeet an e klenge Präis waren gewënscht. Ënnerstëtzung fir discard / null war erfuerderlech, wat vun der Linn an dmesg gepréift gëtt:
kernel: ata1.00: Enabling discard_zeroes_data
2 Stécker NVMe SSD Modell Samsung SSD 970 EVO 500GB.
Fir dës SSDs sinn zoufälleg Lies- / Schreifgeschwindegkeet a Ressourcekapazitéit fir Är Bedierfnesser wichteg. Heizkierper fir hinnen. Noutwendeg. Absolut. Soss, frittéiert se bis knusprech während der éischter RAID Synchroniséierung.
StarTech PEX8M2E2 Adapter fir 2 x NVMe SSD am PCIe 3.0 8x Slot installéiert. Dëst, erëm, ass just en HBA, awer fir NVMe. Et ënnerscheet sech vu bëllegen Adapter an datt et keng PCIe Bifurcatioun Ënnerstëtzung vum Motherboard erfuerdert wéinst der Präsenz vun engem agebaute PCIe Schalter. Et funktionnéiert och am eelste System mat PCIe, och wann et en x1 PCIe 1.0 Slot ass. Natierlech, mat der entspriechender Geschwindegkeet. Et gi keng RAIDs do. Et gëtt keng gebaut-an BIOS u Bord. Also, Äre System léiert net magesch mat NVMe ze booten, vill manner NVMe RAID dank dësem Apparat.
Dës Komponent war eleng wéinst der Präsenz vun nëmmen engem fräi 8x PCIe 3.0 am System, an, wann et 2 fräi Plaze , et kann einfach mat zwee Penny PEX4M2E1 oder Analoga ersat ginn, déi iwwerall zu engem Präis vun kaaft ginn 600 Rubelen.
D'Oflehnung vun all Zort vun Hardware oder agebaute Chipset/BIOS RAIDs gouf bewosst gemaach, fir de ganze System komplett ze ersetzen, mat Ausnam vun der SSD / HDD selwer, wärend all d'Donnéeën erhale bleiwen. Ideal, sou datt Dir souguer den installéierten Betribssystem späichere kënnt wann Dir op komplett nei / aner Hardware plënnert. Den Haapt Saach ass datt et SATA an PCIe Häfen sinn. Et ass wéi eng Live CD oder bootbar Flash Drive, nëmme ganz séier an e bësse voluminös.
HumorSoss wësst Dir wat geschitt - heiansdo musst Dir dréngend déi ganz Array mathuelen fir ewechzehuelen. Mee ech wëll net Daten verléieren. Fir dëst ze maachen, sinn all déi ernimmt Medien bequem op de Rutschen an de 5.25 Bucht vum Standardkëscht.
Gutt, an, natierlech, fir mat verschiddene Methoden vum SSD Caching am Linux ze experimentéieren.
Hardware Iwwerfäll sinn langweileg. Maacht et un. Et funktionnéiert entweder oder net. A mat mdadm ginn et ëmmer Optiounen.
Soft
Virdru gouf Debian 8 Jessie op der Hardware installéiert, déi no bei EOL ass. RAID 6 gouf aus den uewe genannten HDDs zesummegesat mat LVM gepaart. Et leeft virtuell Maschinnen an kvm / libvirt.
Well Den Auteur huet gëeegent Erfahrung fir portable bootbar SATA / NVMe Flash Drive ze kreéieren, an och, fir net déi üblech apt Schabloun ze briechen, gouf Ubuntu 18.04 als Zilsystem gewielt, dee scho genuch stabiliséiert gouf, awer nach ëmmer 3 Joer huet an Zukunft ënnerstëtzen.
De genannte System enthält all d'Hardware Treiber déi mir aus der Këscht brauchen. Mir brauche keng Drëtt Partei Software oder Chauffeuren.
Virbereedung fir d'Installatioun
Fir de System z'installéieren brauche mir Ubuntu Desktop Image. De Serversystem huet eng Aart vu kräftegen Installateur, deen exzessiv Onofhängegkeet weist, déi net ausgeschalt ka ginn andeems d'UEFI Systempartition op eng vun den Disken dréckt, an all d'Schéinheet verwinnt. Deementspriechend ass et nëmmen am UEFI Modus installéiert. Bitt keng Optiounen.
Mir sinn net frou mat dësem.
Firwat?Leider ass UEFI Boot extrem schlecht kompatibel mat Boot Software RAID, well ... Keen bitt eis Reservatioune fir d'UEFI ESP Partition. Et gi Rezepter online déi proposéieren d'ESP Partition op engem Flash Drive an engem USB Hafen ze setzen, awer dëst ass e Punkt vum Echec. Et gi Rezepter mat Software mdadm RAID 1 mat Metadaten Versioun 0.9, déi net verhënneren datt den UEFI BIOS dës Partition gesinn, awer dëst lieft bis de gléckleche Moment, wann de BIOS oder eng aner Hardware OS eppes un den ESP schreift a vergiess se mat aneren ze synchroniséieren Spigelen.
Zousätzlech hänkt UEFI Boot vum NVRAM of, deen net mat den Disken op den neie System beweegt, well ass Deel vum Motherboard.
Also, mir erfannen keen neit Rad. Mir hu schonn e prett-feieren, Zäit-getest Grousspapp d'Vëlo, elo genannt Legacy / BIOS Stiwwel, Droen der stolz Numm vun CSM op UEFI-kompatibel Systemer. Mir huelen et einfach aus dem Regal, schmieren et, pompelen d'Pneuen op a wëschen et mat engem fiichten Tuch.
D'Desktop Versioun vun Ubuntu kann och net richteg mat dem Legacy Bootloader installéiert ginn, awer hei, wéi se soen, op d'mannst ginn et Optiounen.
An dofir sammelen mir d'Hardware a lued de System vum Ubuntu Live bootable Flash Drive. Mir mussen Pakete eroflueden, also setzen mir den Netzwierk op dat fir Iech funktionnéiert. Wann et net funktionnéiert, kënnt Dir am Viraus déi néideg Packagen op e Flash Drive lueden.
Mir ginn an d'Desktop-Ëmfeld, starten den Terminal-Emulator, a mir ginn:
#sudo bash
Wéi…?D'Linn uewendriwwer ass de kanoneschen Ausléiser fir Holiwars iwwer Sudo. C bоméi grouss Chancen kommen anоméi grouss Verantwortung. D'Fro ass ob Dir et op Iech selwer kënnt huelen. Vill Leit mengen datt Sudo op dës Manéier op d'mannst net virsiichteg ass. Allerdéngs:
#apt-get install mdadm lvm2 thin-provisioning-tools btrfs-tools util-linux lsscsi nvme-cli mc
Firwat net ZFS...?Wa mir Software op eisem Computer installéieren, léine mir am Fong eis Hardware un d'Entwéckler vun dëser Software fir ze fueren.
Wa mir dës Software mat der Sécherheet vun eisen Donnéeën vertrauen, huelen mir e Prêt gläich wéi d'Käschte fir dës Donnéeën ze restauréieren, déi mir iergendwann musse bezuelen.
Aus dëser Siicht ass ZFS e Ferrari, an mdadm + lvm ass méi wéi e Vëlo.
Subjektiv léint den Auteur léiwer e Vëlo op Kreditt un onbekannte Leit amplaz e Ferrari. Do ass de Präis vun der Emissioun net héich. Kee Besoin fir Rechter. Méi einfach wéi Verkéiersregelen. Parking ass gratis. Cross-Country Fäegkeet ass besser. Dir kënnt ëmmer Been op e Vëlo befestegt, an Dir kënnt e Vëlo mat Ären eegenen Hänn reparéieren.
Firwat dann BTRFS...?Fir de Betribssystem ze booten, brauche mir e Dateiesystem deen am Legacy/BIOS GRUB aus der Këscht ënnerstëtzt gëtt, a gläichzäiteg Live Snapshots ënnerstëtzt. Mir benotzen et fir d'/boot Partition. Zousätzlech huet den Auteur léiwer dës FS fir / (root) ze benotzen, net ze vergiessen datt Dir fir all aner Software separat Partitionen op LVM erstellt an se an déi néideg Verzeichnisser montéiert.
Mir späicheren keng Biller vu virtuelle Maschinnen oder Datenbanken op dëser FS.
Dëse FS gëtt nëmme benotzt fir Snapshots vum System ze kreéieren ouni se auszeschalten an dann dës Snapshots op eng Backup-Disk iwwerdroen andeems Dir Send/Empfang benotzt.
Zousätzlech huet den Auteur allgemeng léiwer e Minimum vu Software direkt op der Hardware ze halen an all déi aner Software a virtuelle Maschinnen auszeféieren mat Saachen wéi GPUs a PCI-USB Host Controller op KVM iwwer IOMMU weiderzebréngen.
Déi eenzeg Saache lénks op der Hardware sinn Datelagerung, Virtualiséierung a Backup.
Wann Dir ZFS méi trauen, dann, am Prinzip, fir déi spezifizéiert Applikatioun si se austauschbar.
Wéi och ëmmer, den Auteur ignoréiert bewosst déi agebaute Spigelen / RAID a Redundanzfunktiounen déi ZFS, BRTFS an LVM hunn.
Als zousätzlech Argument huet BTRFS d'Fäegkeet fir zoufälleg Schreiwen an sequentiell ze maachen, wat en extrem positiven Effekt op d'Geschwindegkeet vun der Synchroniséierung vu Schnappschëss / Backups op der HDD huet.
Loosst eis all Apparater nei scannen:
#udevadm control --reload-rules && udevadm trigger
Loosst eis e Bléck ronderëm kucken:
#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
Disk Layout
NVMe SSD
Awer mir wäerte se op kee Fall markéieren. All d'selwecht, eise BIOS gesäit dës Drive net. Also, si gi ganz op Software RAID. Mir wäerten do net mol Rubriken schafen. Wann Dir de "Canon" oder "prinzipiell" wëllt verfollegen, erstellt eng grouss Partition, wéi eng HDD.
SATA HDD
Et ass net néideg eppes Besonnesches hei ze erfannen. Mir erstellen eng Sektioun fir alles. Mir wäerten eng Partition erstellen well de BIOS dës Disken gesäit a ka souguer probéieren aus hinnen ze booten. Mir wäerte souguer GRUB op dësen Disken méi spéit installéieren, sou datt de System dat op eemol ka maachen.
#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
Dëst ass wou Saache fir eis interessant ginn.
Als éischt sinn eis Drive 2 TB grouss. Dëst ass am akzeptablen Beräich fir MBR, dat ass wat mir wäerte benotzen. Wann néideg, kann duerch GPT ersat ginn. GPT Disks hunn eng Kompatibilitéitsschicht déi MBR-kompatibel Systemer erlaabt déi éischt 4 Partitionen ze gesinn wa se an den éischten 2 Terabytes sinn. Den Haapt Saach ass datt d'Bootpartition an d'Bios_grub Partition op dësen Disken am Ufank sollt sinn. Dëst erlaabt Iech souguer vu GPT Legacy / BIOS Drive ze booten.
Mä dëst ass net eise Fall.
Hei wäerte mir zwee Sektiounen erstellen. Déi éischt wäert 1 GB grouss sinn a fir RAID 1 /boot benotzt ginn.
Déi zweet gëtt fir RAID 6 benotzt a wäert all déi verbleiwen fräi Plaz ophuelen, ausser e klengt net allokéiert Gebitt um Enn vum Drive.
Wat ass dëst onmarkéiert Gebitt?Laut Quellen am Netz hunn eis SATA SSDs u Bord en dynamesch erweiterbaren SLC Cache mat der Gréisst vu 6 bis 78 Gigabytes. Mir kréien 6 Gigabytes "gratis" wéinst dem Ënnerscheed tëscht "Gigabytes" an "Gibibytes" am Dateblatt vum Drive. Déi reschtlech 72 Gigabytes ginn aus onbenotzten Raum zougewisen.
Hei sollt bemierkt datt mir en SLC Cache hunn, an de Raum ass am 4 Bit MLC Modus besat. Wat fir eis effektiv bedeit datt mir fir all 4 Gigabyte fräi Plaz nëmmen 1 Gigabyte SLC Cache kréien.
Multiplizéiert 72 Gigabyte mat 4 a kritt 288 Gigabyte. Dëst ass de fräie Raum, dee mir net markéieren fir datt d'Drive de SLC Cache voll benotze kënnen.
Sou wäerte mir effektiv bis zu 312 Gigabyte SLC Cache aus insgesamt sechs Drive kréien. Vun all den Drive ginn 2 an RAID fir Redundanz benotzt.
Dëse Betrag u Cache erlaabt eis extrem selten am richtege Liewen eng Situatioun ze begéinen, wou e Schreiwen net an de Cache geet. Dëst kompenséiert extrem gutt fir den trauregsten Nodeel vum QLC Memory - déi extrem niddereg Schreifgeschwindegkeet wann Daten geschriwwe ginn duerch de Cache. Wann Är Lasten net domat entspriechen, da empfeelen ech Iech drun ze denken wéi laang Är SSD ënner esou enger Laascht dauert, andeems Dir den TBW vum Dateblatt berücksichtegt.
#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
Arrays erstellen
Als éischt musse mir d'Maschinn ëmbenennen. Dëst ass noutwendeg well den Hostnumm Deel vum Arraynumm iergendwou bannent mdadm ass an iergendwou eppes beaflosst. Natierlech kënne Arrays méi spéit ëmbenannt ginn, awer dëst ass en onnéidege Schrëtt.
#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
Firwat -uhuelen-propper...?Fir d'Initialiséierung vun Arrays ze vermeiden. Fir béid RAID Niveauen 1 a 6 ass dëst valabel. Alles kann ouni Initialiséierung funktionnéieren wann et eng nei Array ass. Ausserdeem ass d'Initialiséierung vun der SSD-Array bei der Schafung e Verschwendung vun der TBW Ressource. Mir benotzen TRIM / DISCARD wou méiglech op versammelt SSD-Arrays fir se ze "initialiséieren".
Fir SSD-Arrays gëtt RAID 1 DISCARD aus der Këscht ënnerstëtzt.
Fir SSD RAID 6 DISCARD Arrays, musst Dir et an de Kernel Modul Parameteren aktivéieren.
Dëst soll nëmme gemaach ginn wann all SSDs benotzt an Niveau 4/5/6 Arrays an dësem System hunn eng Aarbecht Ënnerstëtzung fir discard_zeroes_data. Heiansdo kommt Dir op komesch Drive, déi dem Kernel soen datt dës Funktioun ënnerstëtzt gëtt, awer tatsächlech ass se net do, oder d'Funktioun funktionnéiert net ëmmer. Am Moment ass d'Ënnerstëtzung bal iwwerall verfügbar, awer et ginn al Drive an Firmware mat Feeler. Aus dësem Grond ass DISCARD Ënnerstëtzung als Standard fir RAID 6 ausgeschalt.
Opgepasst, de folgende Kommando wäert all Daten op NVMe Drive zerstéieren andeems d'Array mat "Nullen" initialiséiert gëtt.
#blkdiscard /dev/md0
Wann eppes falsch geet, probéiert e Schrëtt ze spezifizéieren.
#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
Firwat sou grouss ...?D'Erhéijung vun der Stéckgréisst huet e positiven Effekt op d'Geschwindegkeet vun der zoufälleger Liesung a Blocks bis zu Stéckgréisst inklusiv. Dëst geschitt well eng Operatioun vun der entspriechender Gréisst oder méi kleng ka ganz op engem eenzegen Apparat ofgeschloss ginn. Dofir gëtt d'IOPS vun allen Apparater zesummegefaasst. Laut Statistiken ass 99% vun IO net méi wéi 512K.
RAID huet 6 IOPS pro schreiwen ëmmer manner wéi oder gläich wéi den IOPS vun engem Drive. Wann, als zoufälleg Lies, IOPS kann e puer Mol méi grouss sinn wéi dee vun engem Drive, an hei ass d'Blockgréisst vu Schlësselwichtegkeet.
Den Auteur gesäit net de Punkt fir e Parameter ze optimiséieren deen am RAID 6 By-Design schlecht ass an amplaz optimiséiert wat RAID 6 gutt ass.
Mir kompenséieren fir déi schlecht zoufälleg Schreiwen vun RAID 6 mat engem NVMe Cache an dënn-Provisioning Tricks.
Mir hunn nach net DISCARD aktivéiert fir RAID 6. Also wäerte mir dës Array fir de Moment net "initialiséieren". Mir maachen dat méi spéit, nodeems Dir den OS installéiert hutt.
SATA HDD
#mdadm --create --verbose --assume-clean /dev/md3 --chunk-size=512 --level=6 --raid-devices=8 /dev/sd[g-n]1
LVM op NVMe RAID
Fir Geschwindegkeet wëlle mir de Root-Dateisystem op NVMe RAID 1 placéieren deen /dev/md0.
Wéi och ëmmer, mir brauche nach ëmmer dës séier Array fir aner Bedierfnesser, wéi Swap, Metadaten an LVM-Cache an LVM-dënn Metadaten, sou datt mir en LVM VG op dësem Array erstellen.
#pvcreate /dev/md0
#vgcreate root /dev/md0
Loosst eis eng Partition fir de Root Dateisystem erstellen.
#lvcreate -L 128G --name root root
Loosst eis eng Partition erstellen fir ze tauschen no der Gréisst vum RAM.
#lvcreate -L 32G --name swap root
OS Installatioun
Am Ganzen hu mir alles wat néideg ass fir de System z'installéieren.
Start de Systeminstallatiounswizard aus dem Ubuntu Live Ëmfeld. Normal Installatioun. Nëmmen an der Etapp vun der Auswiel vun Disken fir Installatioun, musst Dir déi folgend spezifizéieren:
- /dev/md1, - Mount Punkt /boot, FS - BTRFS
- /dev/root/root (alias /dev/mapper/root-root), - Mount Point / (root), FS - BTRFS
- /dev/root/swap (alias /dev/mapper/root-swap), - benotzt als Swappartition
- Installéiert de Bootloader op /dev/sda
Wann Dir BTRFS als Root Dateisystem auswielt, erstellt den Installateur automatesch zwee BTRFS Bänn mam Numm "@" fir / (root), an "@home" fir /home.
Loosst eis d'Installatioun ufänken ...
D'Installatioun gëtt mat enger modaler Dialogbox op en Enn, deen e Feeler beim Installéiere vum Bootloader weist. Leider kënnt Dir dësen Dialog net mat Standardmëttelen ausgoen an d'Installatioun weiderféieren. Mir loggen aus dem System an aloggen erëm an, an engem propper Ubuntu Live Desktop Enn. Öffnen den Terminal, an nach eng Kéier:
#sudo bash
Erstellt e Chroot Ëmfeld fir d'Installatioun weiderzemaachen:
#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
Loosst eis den Netzwierk an den Hostnumm am Chroot konfiguréieren:
#cat /etc/hostname >/mnt/chroot/etc/hostname
#cat /etc/hosts >/mnt/chroot/etc/hosts
#cat /etc/resolv.conf >/mnt/chroot/etc/resolv.conf
Loosst eis an d'Chroot Ëmfeld goen:
#chroot /mnt/chroot
Als éischt liwwere mir d'Packagen:
apt-get install --reinstall mdadm lvm2 thin-provisioning-tools btrfs-tools util-linux lsscsi nvme-cli mc debsums hdparm
Loosst eis all Packagen iwwerpréiwen a fixéieren, déi kromm installéiert goufen wéinst onkomplett Systeminstallatioun:
#CORRUPTED_PACKAGES=$(debsums -s 2>&1 | awk '{print $6}' | uniq)
#apt-get install --reinstall $CORRUPTED_PACKAGES
Wann eppes net funktionnéiert, musst Dir vläicht fir d'éischt /etc/apt/sources.list änneren
Loosst eis d'Parameteren fir den RAID 6 Modul upassen fir TRIM / DISCARD z'aktivéieren:
#cat >/etc/modprobe.d/raid456.conf << EOF
options raid456 devices_handle_discard_safely=1
EOF
Loosst eis eis Arrays e bëssen upassen:
#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
Wat war et..?Mir hunn eng Rei vun udev Regelen erstallt déi folgend maachen:
- Setzt d'Block-Cache-Gréisst fir RAID 2020 fir adäquat ze sinn fir 6. De Standardwäert, et schéngt, huet zanter der Schafung vu Linux net geännert a war net laang genuch.
- Reservéiert e Minimum vun IO fir d'Dauer vun Array Kontrollen / Synchronisatiounen. Dëst ass fir ze verhënneren datt Är Arrays an engem Zoustand vun éiweger Synchroniséierung ënner Laascht hänke bleiwen.
- Limitéiert de maximalen IO während Kontrollen / Synchroniséierung vun Arrays. Dëst ass néideg fir datt d'Synchroniséierung / Iwwerpréiwung vun SSD RAIDs Är Fuerwen net zu engem knusprech frittéiert. Dëst ass besonnesch wouer fir NVMe. (Erënnert Iech un de Heizkierper? Ech hu kee Geck gemaach.)
- Verbueden Disken aus der Spindelrotatioun (HDD) iwwer APM ze stoppen a setzt de Schlofzäitout fir Disk Controller op 7 Stonnen. Dir kënnt APM komplett auszeschalten wann Är Fuerwen et maache kënnen (-B 255). Mat dem Standardwäert stoppen d'Drive no fënnef Sekonnen. Da wëll d'OS den Disk Cache zrécksetzen, d'Disks ginn erëm op, an alles fänkt erëm un. Discs hunn eng limitéiert maximal Zuel vun spindle rotations. Sou en einfache Standardzyklus kann Är Disken an e puer Joer einfach ëmbréngen. Net all Disken leiden dovunner, awer eis sinn "Laptop", mat de passenden Standardastellungen, déi d'RAID wéi e Mini-MAID ausgesinn.
- Installéiere Readahead op Disken (rotéierend) 1 Megabyte - zwee konsekutiv Blocks / Chunk RAID 6
- Desaktivéiere Readahead op den Arrays selwer.
Loosst eis /etc/fstab änneren:
#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
Firwat..?Mir sichen no der /boot Partition duerch UUID. Array Numm kéint theoretesch änneren.
Mir sichen no de verbleiwen Sektiounen duerch LVM Nimm an der /dev/mapper/vg-lv Notatioun, well si identifizéieren Partitionen ganz eenzegaarteg.
Mir benotzen net UUID fir LVM well D'UUID vun LVM Bänn an hir Snapshots kënnen d'selwecht sinn.Mount /dev/mapper/root-root .. zweemol?Jo. Genau. Fonktioun vun BTRFS. Dëse Dateisystem kann e puer Mol mat verschiddene Subvolen montéiert ginn.
Wéinst dëser selwechter Feature recommandéieren ech ni LVM Snapshots vun aktive BTRFS Bänn ze kreéieren. Dir kënnt eng Iwwerraschung kréien wann Dir nei starten.
Loosst eis d'mdadm Config regeneréieren:
#/usr/share/mdadm/mkconf | sed 's/#DEVICE/DEVICE/g' >/etc/mdadm/mdadm.conf
Loosst eis d'LVM Astellunge upassen:
#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
Wat war et..?Mir hunn automatesch Expansioun vun LVM dënn Poolen aktivéiert op Erréchen 90% vun der besat Plaz vun 5% vum Volume.
Mir hunn d'maximal Unzuel u Cacheblocken fir LVM Cache erhéicht.
Mir hu verhënnert datt LVM no LVM Bänn (PV) op:
- Apparater mat LVM Cache (cdata)
- Geräter, déi mat LVM Cache gelagert sinn, de Cache ëmgoen ( _corig). An dësem Fall gëtt de Cache-Apparat selwer nach ëmmer duerch de Cache gescannt (just ).
- Apparater mat LVM Cache Metadaten (cmeta)
- all Apparater am VG mat den Numm Biller. Hei wäerte mir Disk-Biller vu virtuelle Maschinnen hunn, a mir wëllen net datt LVM op dem Host Volumen aktivéiert, déi zum Gaascht OS gehéieren.
- all Apparater am VG mam Numm Backupsatellit. Hei wäerte mir Backupkopien vu virtuelle Maschinnbiller hunn.
- all Apparater deenen hiren Numm mat "gpv" endet (physesch Gaaschtvolumen)
Mir hunn DISCARD Ënnerstëtzung aktivéiert wann fräi Plaz fräi Plaz op LVM VG. Sief virsiichteg. Dëst wäert d'Läschen vun LVs op der SSD zimlech Zäitopwendeg maachen. Dëst gëllt speziell fir SSD RAID 6. Wéi och ëmmer, laut dem Plang wäerte mir dënn Versuergung benotzen, sou datt dat eis guer net behënnert.
Loosst eis d'Initramfs Bild aktualiséieren:
#update-initramfs -u -k all
Grub installéieren a konfiguréieren:
#apt-get install grub-pc
#apt-get purge os-prober
#dpkg-reconfigure grub-pc
Wéi eng Discs sollt Dir wielen?All déi sd*. De System muss fäeg sinn aus all funktionnéierenden SATA Drive oder SSD ze booten.
Firwat hunn se os-prober bäigefüügt ..?Fir exzessiv Onofhängegkeet a spilleresch Hänn.
Et funktionnéiert net richteg wann ee vun den RAIDs an engem degradéierte Staat ass. Et probéiert no der OS op Partitionen ze sichen déi a virtuelle Maschinnen benotzt ginn, déi op dëser Hardware lafen.
Wann Dir et braucht, kënnt Dir et verloossen, awer behalen all déi uewe genannten. Ech recommandéieren no Rezepter ze sichen fir naughty Hänn online ze läschen.
Mat dësem hu mir déi initial Installatioun ofgeschloss. Et ass Zäit fir an déi nei installéiert OS nei ze starten. Vergiesst net déi bootbar Live CD / USB ze läschen.
#exit
#reboot
Wielt eng vun den SATA SSDs als Bootapparat.
LVM op SATA SSD
Zu dësem Zäitpunkt hu mir schonn an den neien OS gestart, d'Netzwierk konfiguréiert, apt, den Terminal-Emulator opgemaach an lancéiert:
#sudo bash
Mir weider.
"Initialiséieren" d'Array vun SATA SSD:
#blkdiscard /dev/md2
Wann et net funktionnéiert, probéiert dann:
#blkdiscard --step 65536 /dev/md2
Erstellt LVM VG op SATA SSD:
#pvcreate /dev/md2
#vgcreate data /dev/md2
Firwat nach en VG..?Tatsächlech hu mir schonn e VG mam Numm Root. Firwat net alles an een VG addéieren?
Wann et e puer PVs an engem VG sinn, da fir datt de VG richteg aktivéiert ass, mussen all PVs präsent sinn (online). D'Ausnam ass LVM RAID, déi mir bewosst net benotzen.
Mir wëllen wierklech datt wann et e Feeler ass (liesen Datenverloscht) op eng vun den RAID 6-Arrays, de Betribssystem wäert normalerweis booten an eis d'Méiglechkeet ginn de Problem ze léisen.
Fir dëst ze maachen, wäerte mir um éischten Abstraktiounsniveau all Typ vu kierperleche "Medien" an eng separat VG isoléieren.
Wëssenschaftlech gesinn, verschidde RAID-Arrays gehéieren zu verschiddenen "Zouverlässegkeetsdomänen". Dir sollt net en zousätzleche gemeinsame Punkt vum Echec fir si kreéieren andeems Dir se an ee VG kräizt.
D'Präsenz vu LVM um "Hardware" Niveau erlaabt eis arbiträr Stécker vu verschiddene RAID-Arrays ze schneiden andeems se se op verschidde Manéieren kombinéieren. Zum Beispill - lafen gläichzäiteg bcache + LVM dënn, bcache + BTRFS, LVM Cache + LVM dënn, eng komplex ZFS Konfiguratioun mat Cache, oder all aner hellesch Mëschung fir ze probéieren alles ze vergläichen.
Um "Hardware" Niveau wäerte mir näischt anescht wéi gutt al "déck" LVM Bänn benotzen. D'Ausnam zu dëser Regel kann d'Backuppartition sinn.
Ech mengen zu dësem Moment hu vill Lieser schonn ugefaang eppes iwwer d'Nistpopp ze verdächtegen.
LVM op SATA HDD
#pvcreate /dev/md3
#vgcreate backup /dev/md3
Neien VG erëm..?Mir wëllen wierklech datt wann d'Diskarray, déi mir fir Datebackup benotze wäerten, feelt, eise Betribssystem weider normal funktionnéiert, wärend den Zougang zu Net-Backupdaten wéi gewinnt behält. Dofir, fir VG Aktivéierungsproblemer ze vermeiden, kreéiere mir eng separat VG.
LVM Cache opsetzen
Loosst eis en LV op NVMe RAID 1 erstellen fir et als Caching-Apparat ze benotzen.
#lvcreate -L 70871154688B --name cache root
Firwat gëtt et sou wéineg...?De Fakt ass datt eis NVMe SSDs och en SLC Cache hunn. 4 Gigabyte "gratis" an 18 Gigabyte Dynamik wéinst dem fräie Raum, deen am 3-Bit MLC besat ass. Wann dëse Cache erschöpft ass, sinn NVMe SSDs net vill méi séier wéi eis SATA SSD mat Cache. Eigentlech, aus dësem Grond, mécht et kee Sënn fir eis d'LVM Cache Partition vill méi grouss ze maachen wéi zweemol d'Gréisst vum SLC Cache vum NVMe Drive. Fir d'NVMe Drive benotzt, hält den Auteur et raisonnabel fir 32-64 Gigabytes Cache ze maachen.
Déi gegebene Partitionsgréisst ass erfuerderlech fir 64 Gigabytes Cache, Cache Metadaten a Metadaten Backup ze organiséieren.
Zousätzlech bemierken ech datt no engem dreckeg System Shutdown, LVM de ganze Cache als dreckeg markéiert an erëm synchroniséiert. Ausserdeem gëtt dëst all Kéier widderholl wann lvchange op dësem Apparat benotzt gëtt bis de System erëm nei gestart gëtt. Dofir recommandéieren ech direkt de Cache nei ze kreéieren mat dem passenden Skript.
Loosst eis en LV op SATA RAID 6 erstellen fir et als cachéiert Apparat ze benotzen.
#lvcreate -L 3298543271936B --name cache data
Firwat nëmmen dräi Terabytes ..?Also, wann néideg, kënnt Dir SATA SSD RAID 6 fir e puer aner Besoinen benotzen. D'Gréisst vum cache Raum kann dynamesch erhéicht ginn, op der Flucht, ouni de System ze stoppen. Fir dëst ze maachen, musst Dir de Cache temporär stoppen an nei aktivéieren, awer de markanten Virdeel vum LVM-Cache iwwer zum Beispill bcache ass datt dëst op der Flucht ka gemaach ginn.
Loosst eis en neie VG fir Caching erstellen.
#pvcreate /dev/root/cache
#pvcreate /dev/data/cache
#vgcreate cache /dev/root/cache /dev/data/cache
Loosst eis e LV op dem cachéierten Apparat erstellen.
#lvcreate -L 3298539077632B --name cachedata cache /dev/data/cache
Hei hu mir direkt all fräi Plaz op /dev/data/cache opgeholl, sou datt all aner noutwendeg Partitionen direkt op /dev/root/cache erstallt goufen. Wann Dir eppes op der falscher Plaz erstallt hutt, kënnt Dir et mat pvmove réckelen.
Loosst eis de Cache erstellen an aktivéieren:
#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
Firwat esou Stécker..?Duerch praktesch Experimenter konnt den Auteur erausfannen, datt dat bescht Resultat erreecht gëtt, wann d'Gréisst vum LVM-Cache-Block mat der Gréisst vum LVM-dënnem Block entsprécht. Ausserdeem, wat méi kleng d'Gréisst ass, dest besser ass d'Konfiguratioun an enger zoufälleger Opnam.
64k ass déi Minimum Blockgréisst erlaabt fir LVM dënn.
Sidd virsiichteg Schreifweis ..!Jo. Dës Aart vu Cache stellt d'Schreifsynchroniséierung op den cache-Apparat of. Dëst bedeit datt wann de Cache verluer ass, kënnt Dir Daten um cachéierten Apparat verléieren. Spéider wäert den Auteur Iech soen wéi eng Moossnamen, zousätzlech zu NVMe RAID 1, geholl kënne ginn fir dëse Risiko ze kompenséieren.
Dëse Cache-Typ gouf virsiichteg gewielt fir déi schlecht zoufälleg Schreifleistung vum RAID 6 ze kompenséieren.
Loosst eis kucken wat mir hunn:
#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)
Nëmmen [cachedata_corig] soll op /dev/data/cache sinn. Wann eppes falsch ass, da benotzt pvmove.
Dir kënnt de Cache deaktivéieren wann néideg mat engem Kommando:
#lvconvert -y --uncache cache/cachedata
Dëst gëtt online gemaach. LVM synchroniséiert einfach de Cache op Disk, läscht se an ëmbenannt cachedata_corig zréck op Cachedata.
Ariichten LVM dënn
Loosst eis ongeféier schätzen wéi vill Plaz mir fir LVM dënn Metadaten brauchen:
#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"
Ronn bis zu 4 gigabytes: 4294967296B
Multiplizéiert mat zwee a füügt 4194304B fir LVM PV Metadaten derbäi: 8594128896B
Loosst eis eng separat Partition op NVMe RAID 1 erstellen fir LVM dënn Metadaten an hir Backupkopie drop ze setzen:
#lvcreate -L 8594128896B --name images root
Fir wat..?Hei kann d'Fro stellen: firwat LVM dënn Metadaten getrennt placéieren wann se nach ëmmer op NVMe cache ginn a séier funktionnéieren.
Och wann d'Vitesse hei wichteg ass, ass et wäit vum Haaptgrond. D'Saach ass datt de Cache e Punkt vum Echec ass. Eppes kéint dermat geschéien, a wann d'LVM dënn Metadaten cache sinn, féiert dat alles komplett verluer. Ouni komplette Metadaten wäert et bal onméiglech sinn dënn Bänn ze sammelen.
Andeems Dir d'Metadaten op e separaten net-cachéierten, awer séieren Volumen beweegt, garantéieren mir d'Sécherheet vun de Metadaten am Fall vu Cacheverloscht oder Korruptioun. An dësem Fall gëtt all Schued, deen duerch Cacheverloscht verursaacht gëtt, bannent dënnen Bänn lokaliséiert, wat d'Erhuelungsprozedur duerch Uerdnung vun der Gréisst vereinfacht. Mat enger grousser Wahrscheinlechkeet ginn dës Schied mat FS Logbicher restauréiert.
Ausserdeem, wann e Snapshot vun engem dënnen Volumen virdru geholl gouf, an duerno de Cache op d'mannst eemol voll synchroniséiert gouf, dann, wéinst dem internen Design vun LVM dënn, gëtt d'Integritéit vum Snapshot am Fall vum Cacheverloscht garantéiert .
Loosst eis en neie VG erstellen, dee verantwortlech ass fir dënn Versuergung:
#pvcreate /dev/root/images
#pvcreate /dev/cache/cachedata
#vgcreate images /dev/root/images /dev/cache/cachedata
Loosst eis e Pool erstellen:
#lvcreate -L 274877906944B --poolmetadataspare y --poolmetadatasize 4294967296B --chunksize 64k -Z y -T images/thin-pool
Firwat -Z yZousätzlech zu deem wat dëse Modus eigentlech geduecht ass - fir ze verhënneren datt Daten vun enger virtueller Maschinn op eng aner virtuell Maschinn lekken wann de Raum ëmverdeelt - gëtt d'Nulléierung zousätzlech benotzt fir d'Geschwindegkeet vum zoufälleg Schreiwen a Blocken méi kleng wéi 64k ze erhéijen. All Schreifweis manner wéi 64k op e virdrun net allokéiert Gebitt vum dënnen Volume gëtt 64K Rand-ausgeriicht am Cache. Dëst erlaabt d'Operatioun ganz duerch de Cache auszeféieren, andeems de Cache-Apparat ëmgeet.
Loosst eis d'LVs op déi entspriechend PVs réckelen:
#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
Loosst eis kucken:
#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)
Loosst eis en dënnen Volume fir Tester erstellen:
#lvcreate -V 64G --thin-pool thin-pool --name test images
Mir installéieren Pakete fir Tester an Iwwerwaachung:
#apt-get install sysstat fio
Dëst ass wéi Dir d'Behuele vun eiser Späicherkonfiguratioun an Echtzäit observéiere kënnt:
#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)'
Dëst ass wéi mir eis Konfiguratioun testen:
#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
Virsiichteg! Ressource!Dëse Code wäert lafen 36 verschidden Tester, all Lafen fir 4 Sekonnen. D'Halschent vun den Tester si fir Opnam. Dir kënnt vill op NVMe a 4 Sekonnen ophuelen. Bis zu 3 Gigabyte pro Sekonn. Also, all Laf vu Schreiftester kann bis zu 216 Gigabyte vun SSD Ressource vun Iech iessen.
Liesen a Schreiwen gemëscht?Jo. Et mécht Sënn fir d'Lies- a Schreiftester separat auszeféieren. Ausserdeem ass et Sënn fir sécherzestellen datt all Cache synchroniséiert sinn, sou datt e virdru gemaachte Schreiwen net d'Liesen beaflosst.
D'Resultater wäerten immens variéieren wärend dem éischte Start a spéider wéi de Cache an d'dënne Volumen ausfëllen, an och ofhängeg ob de System et fäerdeg bruecht huet d'Cache ze synchroniséieren déi während dem leschte Start gefëllt sinn.
Ënnert anerem recommandéieren ech d'Geschwindegkeet op engem scho vollen dënnen Volumen ze moossen, aus deem e Snapshot just gemaach gouf. Den Auteur hat d'Méiglechkeet ze beobachten wéi zoufälleg Schreiwen direkt no der Schafung vun der éischter Schnappschëss séier séier beschleunegen, besonnesch wann de Cache nach net ganz voll ass. Dëst geschitt wéinst Kopie-op-schreiwen Schreiwen Semantik, Ausriichtung vun Cache an dënn Volumen Spär, an der Tatsaach, datt eng zoufälleg Schreiwen ze RAID 6 gëtt zu engem zoufälleg liesen aus RAID 6 gefollegt vun engem Schreiwen op de Cache. An eiser Konfiguratioun ass zoufälleg Liese vu RAID 6 bis zu 6 Mol (d'Zuel vun de SATA SSDs an der Array) méi séier wéi ze schreiwen. Well Blocks fir CoW ginn sequenziell aus engem dënnen Pool zougewisen, da gëtt d'Opname zum gréissten Deel och an sequenziell.
Béid vun dëse Funktiounen kënnen op Äre Virdeel benotzt ginn.
Cache "kohärent" Schnappschëss
Fir de Risiko vun Datenverloscht am Fall vun Cache Schued / Verloscht ze reduzéieren, proposéiert den Auteur d'Praxis vun rotéierende Schnappschëss virzestellen fir hir Integritéit an dësem Fall ze garantéieren.
Als éischt, well dënn Volumen Metadaten op engem ongecachéierten Apparat wunnen, wäerten d'Metadaten konsequent sinn a méiglech Verloschter ginn an Datenblocken isoléiert.
De folgende Snapshot Rotatiounszyklus garantéiert d'Integritéit vun den Donnéeën an de Schnappschëss am Fall vum Cacheverloscht:
- Fir all dënn Volumen mam Numm <Numm>, erstellt e Schnappschëss mam Numm <Numm>.cached
- Loosst eis d'Migratiounsschwell op e verstännegen héije Wäert setzen:
#lvchange --quiet --cachesettings "migration_threshold=16384" cache/cachedata - An der Loop kontrolléieren mir d'Zuel vun dreckeg Blocken am Cache:
#lvs --rows --reportformat basic --quiet -ocache_dirty_blocks cache/cachedata | awk '{print $2}'bis mir null kréien. Wann d'Null ze laang fehlt, kann se erstallt ginn andeems de Cache temporär an de Schreifmodus wiesselt. Wéi och ëmmer, andeems Dir d'Geschwindegkeetskarakteristike vun eise SATA- an NVMe SSD-Arrays berücksichtegt, souwéi hir TBW-Ressource, kënnt Dir entweder fäeg sinn de Moment séier ze fangen ouni de Cache-Modus z'änneren, oder Är Hardware iesst seng ganz Ressource komplett op. e puer Deeg. Wéinst Ressourcebeschränkungen ass de System am Prinzip net ëmmer fäeg ënner 100% Schreiflaascht ze sinn. Eis NVMe SSDs ënner 100% Schreiflast wäerten d'Ressource komplett ausschöpfen 3-4 Deeg. SATA SSDs wäerten nëmmen zweemol sou laang daueren. Dofir, wäerte mir dovun ausgoen, datt déi meescht vun der Laascht op liesen geet, a mir hu relativ kuerzfristeg Ausbroch vun extrem héich Aktivitéit kombinéiert mat engem niddereg Laascht am Duerchschnëtt fir Schreiwen. - Soubal mir eng Null gefaangen (oder gemaach hunn), ëmbenennen mir <name>.cached op <name>.committed. Den alen <name>.committed gëtt geläscht.
- Optional, wann de Cache 100% voll ass, kann et vun engem Skript nei erstallt ginn, sou datt et geläscht gëtt. Mat engem hallef eidelen Cache funktionnéiert de System vill méi séier beim Schreiwen.
- Setzt d'Migratiounsschwell op Null:
#lvchange --quiet --cachesettings "migration_threshold=0" cache/cachedataDëst wäert temporär verhënneren datt de Cache mat den Haaptmedien synchroniséiert. - Mir waarden bis zimlech vill Ännerungen am Cache accumuléieren
#lvs --rows --reportformat basic --quiet -ocache_dirty_blocks cache/cachedata | awk '{print $2}'oder den Timer geet aus. - Mir widderhuelen nach eng Kéier.
Firwat Schwieregkeeten mat Migratiounsschwell...?D'Saach ass datt an der realer Praxis eng "zoufälleg" Opnam tatsächlech net ganz zoufälleg ass. Wa mir eppes un e Secteur vu 4 Kilobytes an der Gréisst geschriwwen hunn, ass et eng grouss Wahrscheinlechkeet datt an den nächste puer Minutten e Rekord op déiselwecht oder ee vun den Nopeschsektoren (+- 32K) gemaach gëtt.
Andeems Dir d'Migratiounsschwell op Null setzt, stellen mir d'Schreifsynchroniséierung op der SATA SSD of a aggregéiere verschidde Ännerunge fir ee 64K Block am Cache. Dëst spuert bedeitend d'Ressource vun der SATA SSD.
Wou ass de Code..?Leider hält den Auteur sech net genuch kompetent an der Entwécklung vu Bash Scripten well hien 100% selbstgeléiert ass an "google" gedriwwen Entwécklung praktizéiert, dofir mengt hien datt de schreckleche Code deen aus sengen Hänn kënnt net vu jidderengem benotzt ginn. soss.
Ech denken, datt Professionnelen an dësem Beräich fäeg sinn all déi uewe beschriwwe Logik onofhängeg duerzestellen, wann néideg, a vläicht souguer schéin als Systemdéngscht ze designen, wéi den Auteur probéiert huet.
Sou en einfachen Schnappschëss Rotatiounsschema erlaabt eis net nëmmen dauernd e Snapshot komplett op der SATA SSD synchroniséiert ze hunn, awer et erlaabt eis och, andeems Dir den Thin_delta Utility benotzt, erauszefannen, wéi eng Blocks no senger Schafung geännert goufen, an domat Schued lokaliséieren op d'Haaptbänn, d'Erhuelung staark vereinfacht.
TRIM/DISCARD an libvirt/KVM
Well d'Datespäicherung gëtt fir KVM benotzt déi libvirt leeft, da wier et eng gutt Iddi fir eis VMs net nëmme fräi Plaz opzehuelen, awer och fräi ze maachen wat net méi gebraucht gëtt.
Dëst gëtt gemaach andeems Dir TRIM / DISCARD Support op virtuelle Disken emuléiert. Fir dëst ze maachen, musst Dir de Controllertyp op virtio-scsi änneren an d'Xml änneren.
#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>
Esou DISCARDs vu Gaascht OSe ginn korrekt vun LVM veraarbecht, a Blocke ginn korrekt souwuel am Cache wéi och am dënnen Pool befreit. An eisem Fall geschitt dat haaptsächlech op eng verspéit Manéier, wann de nächste Schnappschëss geläscht gëtt.
BTRFS Backupsatellit
Benotzen fäerdeg Scripten mat verlängert virsiichteg an op eegene Risiko. Den Auteur huet dëse Code selwer an exklusiv fir sech selwer geschriwwen. Ech si sécher datt vill erfuerene Linux Benotzer ähnlech Tools hunn, an et ass kee Besoin fir een aneren ze kopéieren.
Loosst eis e Volumen um Backup-Apparat erstellen:
#lvcreate -L 256G --name backup backup
Loosst eis et an BTRFS formatéieren:
#mkfs.btrfs /dev/backup/backup
Loosst eis Montéierungspunkten erstellen an d'Root-Ënnersektioune vum Dateiesystem montéieren:
#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
Loosst eis Verzeichnisser fir Backups erstellen:
#mkdir /backup/btrfs/back/remote
#mkdir /backup/btrfs/back/remote/root
#mkdir /backup/btrfs/back/remote/boot
Loosst eis e Verzeechnes fir Backup-Skripte erstellen:
#mkdir /root/btrfs-backup
Loosst eis de Skript kopéieren:
Vill grujeleg Bash Code. Benotzt op Ären eegene Risiko. Schreift keng rosen Bréiwer un den Auteur ...#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
Wat mécht et iwwerhaapt..?Enthält eng Rei vun einfache Befehle fir BTRFS Schnappschëss ze kreéieren an se op eng aner FS ze kopéieren andeems Dir BTRFS schécken / kréien.
Den éischte Start ka relativ laang sinn, well ... Am Ufank ginn all Daten kopéiert. Weider Starte wäerte ganz séier sinn, well ... Nëmmen Ännerungen ginn kopéiert.
En anert Skript dat mir a Cron setzen:
E puer méi Bash Code#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
Wat mécht et..?Erstellt a synchroniséiert inkrementell Schnappschëss vun de opgelëscht BTRFS Bänn op der Backup FS. Duerno läscht se all Biller déi viru 60 Deeg erstallt goufen. Nom Start erschéngen datéiert Schnappschëss vun de opgezielte Bänn an den /backup/btrfs/back/remote/ Ënnerverzeechnes.
Loosst eis de Code Ausféierungsrechter ginn:
#chmod +x /root/btrfs-backup/cron-daily.sh
#chmod +x /root/btrfs-backup/btrfs-backup.sh
Loosst eis et iwwerpréiwen a setzen se an de Cron:
#/usr/bin/nice -n 19 /usr/bin/ionice -c 3 /root/btrfs-backup/cron-daily.sh 2>&1 | /usr/bin/logger -t btrfs-backup
#cat /var/log/syslog | grep btrfs-backup
#crontab -e
0 2 * * * /usr/bin/nice -n 19 /usr/bin/ionice -c 3 /root/btrfs-backup/cron-daily.sh 2>&1 | /usr/bin/logger -t btrfs-backup
LVM dënn Backupsatellit
Loosst eis en dënnen Pool um Backup-Apparat erstellen:
#lvcreate -L 274877906944B --poolmetadataspare y --poolmetadatasize 4294967296B --chunksize 64k -Z y -T backup/thin-pool
Loosst eis ddrescue installéieren, well ... Scripte wäerten dëst Tool benotzen:
#apt-get install gddrescue
Loosst eis e Verzeechnes fir Skripte erstellen:
#mkdir /root/lvm-thin-backup
Loosst eis d'Skripte kopéieren:
Vill bannen ...#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
Wat mécht et...?Enthält eng Rei vu Befehle fir dënn Snapshots ze manipuléieren an den Ënnerscheed tëscht zwee dënn Snapshots ze synchroniséieren, déi iwwer thin_delta op en anere Blockapparat mat ddrescue a blkdiscard kritt goufen.
En anert Skript dat mir a Cron setzen:
E bësse méi schlëmm#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
Wat mécht et...?Benotzt de fréiere Skript fir Backupe vun den opgelëschten dënnen Bänn ze kreéieren an ze synchroniséieren. De Skript léisst inaktiv Schnappschëss vun de opgezielte Bänn, déi néideg sinn fir Ännerungen zanter der leschter Synchroniséierung ze verfolgen.
Dëst Skript muss geännert ginn, spezifizéiert d'Lëscht vun dënnen Bänn, fir déi Backupkopien gemaach ginn. D'Nimm uginn sinn nëmme fir Illustratioun Zwecker. Wann Dir wëllt, kënnt Dir e Skript schreiwen, deen all Bänn synchroniséiert.
Loosst eis d'Rechter ginn:
#chmod +x /root/lvm-thin-backup/cron-daily.sh
#chmod +x /root/lvm-thin-backup/lvm-thin-backup.sh
Loosst eis et iwwerpréiwen a setzen se an de Cron:
#/usr/bin/nice -n 19 /usr/bin/ionice -c 3 /root/lvm-thin-backup/cron-daily.sh 2>&1 | /usr/bin/logger -t lvm-thin-backup
#cat /var/log/syslog | grep lvm-thin-backup
#crontab -e
0 3 * * * /usr/bin/nice -n 19 /usr/bin/ionice -c 3 /root/lvm-thin-backup/cron-daily.sh 2>&1 | /usr/bin/logger -t lvm-thin-backup
Den éischte Start wäert laang sinn, well ... dënn Bänn wäert voll synchroniséiert ginn duerch Kopie all benotzt Plaz. Dank LVM dënn Metadaten wësse mir wéi eng Blocks tatsächlech am Gebrauch sinn, sou datt nëmmen tatsächlech benotzt dënn Volumenblocken kopéiert ginn.
Déi spéider Runen kopéieren d'Donnéeën inkrementell dank der Ännerung vum Tracking iwwer LVM dënn Metadaten.
Loosst eis kucken wat geschitt ass:
#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
Wat huet dat mat Naschtpoppen ze dinn?
Wahrscheinlech, well LVM LV logesch Bänn kënne LVM PV kierperlech Bänn fir aner VGs sinn. LVM ka rekursiv sinn, sou wéi Nistpoppen. Dëst gëtt LVM extrem Flexibilitéit.
PS
Am nächsten Artikel wäerte mir probéieren e puer ähnlech mobil Späichersystemer / KVM als Basis ze benotzen fir e geo-verdeelte Späicher / vm Cluster ze kreéieren mat Redundanz op verschiddene Kontinenter mat Heemdesktops, dem Heem Internet a P2P Netzwierker.
Source: will.com