Fragmentering er et langvarig problem når det gjelder lagring. Det oppstår når lagringsmediet på grunn av langvarig bruk får biter av tildelte blokker med ledig plass mellom seg. Dette skjer fordi forskjellige programmer ber om minne i annen rekkefølge, og deretter frigjør minnet til forskjellige tider. Å ha biter av ikke allokert plass mellom data reduserer den totale tilgjengelige plassen på disken (lagringseffektivitet) og også ytelsen til disken, siden dataene ikke er lagret i en stor sammenhengende del, men spredt over disken.

Dette problemet er spesielt tydelig i magnetiske medier, selv om SSD-er også lider av det. La oss prøve å defragmentere et XFS-filsystem i dette innlegget.

Oppsett av sandkasse

Først, for å eksperimentere med XFS-filsystem, bestemte jeg meg for å lage en testbenk i stedet for å jobbe med kritiske data på en disk. Denne testbenken består av en Ubuntu VM som en virtuell disk er koblet til som gir rå lagring. Du kan bruke VirtualBox til å opprette VM og deretter opprette en ekstra disk for å knytte til VM

Bare gå til VM-innstillingene og under Innstillinger → Lagring delen kan du legge til en ny disk i SATA-kontrolleren. Du kan opprette en ny disk. Som vist nedenfor, men sørg for at VM er slått av når du gjør dette.

Når den nye disken er opprettet, slår du på VM og åpner terminalen. Kommandoen lsblk lister opp alle tilgjengelige blokkenheter.

$ lsblk
sda 8: 0 0 60G 0 disk
├─sda1 8: 1 0 1M 0 del
└─sda2 8: 2 0 60G 0 del /
sdb 8:16 0 100G 0 disk
sr0 11: 0 1 1024M 0 rom

Bortsett fra hovedblokkingsenheten sda, der operativsystemet er installert, er det nå en ny sdb-enhet. La oss raskt lage en partisjon fra den og formatere den med XFS-filsystem.

Åpne opp delt verktøy som rotbruker:

$ delt - en optimal / dev / sdb

La oss lage en partisjonstabell først ved hjelp av mklabel, dette blir fulgt av å opprette en enkelt partisjon ut av hele disken (som er 107 GB i størrelse). Du kan bekrefte at partisjonen er laget ved å liste den med utskriftskommandoen:

(skilt) mklabel gpt
(skilt) mkpart primær 0 107
(delt) trykk
(skilt) sluttet

Ok, nå kan vi se ved hjelp av lsblk at det er en ny blokkeringsenhet under sdb-enheten, kalt sdb1.

La oss formatere denne lagringsplassen som xfs og montere den i / mnt-katalogen. Igjen, gjør følgende handlinger som rot:

$ mkfs.xfs / dev / sdb1
$ mount / dev / sdb1 / mnt
$ df -h

Den siste kommandoen vil skrive ut alle de monterte filsystemene, og du kan sjekke at / dev / sdb1 er montert på / mnt.

Deretter skriver vi en haug med filer som dummy-data for å defragmentere her:

$ dd if = / dev / urandom of = / mnt / myfile.txt-antall = 1024 bs = 1024

Kommandoen ovenfor vil skrive en filfil.tekst på 1 MB størrelse. Du kan automatisere denne kommandoen til en enkel for loop ved hjelp av bash og generere flere slike filer. Spre dem over forskjellige kataloger hvis du vil. Slett noen få av dem tilfeldig. Gjør alt dette inne i xfs-filsystemet (montert på / mnt) og se etter fragmentering. Alt dette er selvfølgelig valgfritt.

Defragmenter filsystemet

Det første vi må gjøre er å finne ut hvordan vi kan kontrollere mengden fragmentering. For eksempel var xfs-filsystemet vi opprettet tidligere på enhetsnode / dev / sdb. Vi kan bruke verktøyet xfs_db (står for xfs feilsøking) for å sjekke fragmenteringsnivået.

$ xfs_db -c frag -r / dev / sdb1

Flagget -c tar forskjellige kommandoer, blant annet er frag-kommandoen for å kontrollere fragmenteringsnivået. Flagget -r brukes til å sikre at operasjonen er skrivebeskyttet.

Hvis vi finner ut at det er fragmentering i dette filsystemet, kjører vi kommandoen xfs_fsr på enhetsnoden:

$ xfs_fsr / dev / sdb1

Denne siste kommandoen er alt det er å defragmentere filsystemet ditt, du kan legge til dette som en cronjob som regelmessig vil overvåke filsystemet ditt. Men å gjøre det for xfs gir liten mening. Den omfangsbaserte tildelingen av XFS sikrer at problemer som fragmentering holder seg på et minimum.

Bruk tilfeller

Brukstilfellene der du trenger å bekymre deg mest om filsystemfragmentering innebærer applikasjoner der mange små biter av data skrives og skrives om. En database er et klassisk eksempel på dette, og databaser er beryktet for å legge igjen mange "hull" i lagringen din. Minneblokker fylles ikke sammenhengende, noe som gjør mengden tilgjengelig plass mindre og mindre over tid.

Problemet oppstår som ikke bare når det gjelder redusert brukbar plass, men også når det gjelder redusert IOPS som kan skade applikasjonens ytelse. Å ha et skript for kontinuerlig å overvåke fragmenteringsnivået er en konservativ måte å vedlikeholde systemet på. Du vil ikke at et automatisert skript vil starte tilfeldig defragmentering av filsystemet, spesielt når det brukes ved toppbelastning.