DevOps-bootcamp · Les

Schijven, bestandssystemen en mountbewerkingen automatiseren

Inspecteer block devices, beheer fstab-vermeldingen en automatiseer LVM- en mountbewerkingen veilig.

Les 3 van 413 stappen

Schijven, bestandssystemen en mountbewerkingen automatiseren is een gratis DevOps-bootcamp-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject DevOps-bootcamp. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus DevOps-bootcamp bevat in totaal 4 lessen.

Blokapparaten begrijpen met lsblk en fdisk

Voordat je schijfbewerkingen automatiseert, moet je kunnen inspecteren welke blokapparaten op het systeem aanwezig zijn. Twee essentiële hulpmiddelen zijn lsblk en fdisk -l.

lsblk — geeft blokapparaten weer in een boomstructuur met apparaatnamen, grootten, aankoppelpunten en typen (disk, part, lvm)
fdisk -l — toont partitietabellen en sectorgegevens (rootrechten vereist)
blkid — geeft UUID's en bestandssysteemtypen voor elk blokapparaat weer

In scripts moet je deze uitvoer vaak parseren om beschikbare schijven te detecteren, te controleren of een partitie is geformatteerd of de UUID ervan te bepalen voordat je deze aankoppelt.

#!/usr/bin/env bash
# Inspect all block devices and their UUIDs
set -euo pipefail

echo '=== Block Device Tree ==='
lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT,UUID

echo ''
echo '=== Partition Table Details ==='
sudo fdisk -l 2>/dev/null | grep -E '^Disk |^/dev/'

echo ''
echo '=== UUID Lookup via blkid ==='
sudo blkid | awk -F: '{print $1}' | while read -r dev; do
  uuid=$(sudo blkid -s UUID -o value "$dev" 2>/dev/null || echo 'N/A')
  fstype=$(sudo blkid -s TYPE -o value "$dev" 2>/dev/null || echo 'unknown')
  printf '%-20s UUID=%-38s TYPE=%s\n' "$dev" "$uuid" "$fstype"
done

Schijfruimte controleren met df en du

df en du zijn de belangrijkste hulpmiddelen voor het rapporteren van gebruik door bestandssystemen en mappen. In scripts voor systeembeheer gebruik je ze om waarschuwingen te activeren, quota af te dwingen of te bepalen wanneer je meer ruimte moet toewijzen.

df -h — gebruik van bestandssystemen in leesbare vorm voor alle aangekoppelde bestandssystemen
df -BG — uitvoer in gigabytes voor consistente numerieke verwerking
du -sh /path — samengevatte grootte van een specifieke map
du -d 1 /var — overzicht tot één niveau diep (handig om te vinden welke submap groot is)

De kolom percent used van df wordt vaak verwerkt om waarschuwingen voor een volle schijf te activeren in bewakingsscripts.

#!/usr/bin/env bash
# Alert if any mounted filesystem exceeds a usage threshold
set -euo pipefail

THRESHOLD=80   # percent

echo 'Checking filesystem usage...'
df -h --output=source,pcent,target | tail -n +2 | while IFS= read -r line; do
  device=$(awk '{print $1}' <<< "$line")
  pct=$(awk '{print $2}' <<< "$line" | tr -d '%')
  mount=$(awk '{print $3}' <<< "$line")

  # Skip pseudo filesystems
  [[ "$device" == tmpfs* || "$device" == devtmpfs* ]] && continue

  if (( pct >= THRESHOLD )); then
    echo "WARNING: $device mounted at $mount is ${pct}% full" >&2
  else
    echo "OK: $device at $mount is ${pct}% used"
  fi
done

/etc/fstab lezen en parseren

/etc/fstab is de statische bestandssysteemtabel — hierin staat welke apparaten tijdens het opstarten worden aangekoppeld, op welk pad en met welke opties. Elke regel bevat zes velden:

Apparaat — UUID=..., LABEL=... of /dev/sdX
Aankoppelpunt — pad naar de map
Bestandssysteemtype — ext4, xfs, nfs, tmpfs enzovoort
Opties — defaults, ro, noexec, nofail enzovoort
Dump — 0 of 1 (back-upvlag)
Pass — 0, 1 of 2 (volgorde voor fsck)

Scripts die fstab-vermeldingen toevoegen of valideren, moeten opmerkingen (regels die beginnen met #) en lege regels correct verwerken. Geef altijd de voorkeur aan UUID's boven apparaatnamen, zodat het systeem blijft werken na herstarts waarbij de volgorde van apparaten kan veranderen.

#!/usr/bin/env bash
# Parse /etc/fstab and display non-comment entries in a readable table
set -euo pipefail

FSTAB=/etc/fstab

printf '%-40s %-20s %-10s %s\n' 'DEVICE' 'MOUNTPOINT' 'FSTYPE' 'OPTIONS'
printf '%s\n' '-------------------------------------------------------------------------------------'

while IFS= read -r line; do
  # Skip blank lines and comments
  [[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue

  read -r device mountpt fstype options _dump _pass <<< "$line"
  printf '%-40s %-20s %-10s %s\n' "$device" "$mountpt" "$fstype" "$options"
done < "$FSTAB"

Veilig een fstab-vermelding toevoegen

/etc/fstab handmatig bewerken is foutgevoelig. Een onjuiste vermelding kan voorkomen dat het systeem opstart. Een veilig automatiseringsscript moet:

Controleren of de vermelding al bestaat voordat deze wordt toegevoegd (idempotentie)
Een back-up van het oorspronkelijke bestand maken voordat er iets wordt gewijzigd
UUID gebruiken in plaats van een apparaatpad
nofail aan de koppelopties toevoegen, zodat een ontbrekende schijf het opstarten niet blokkeert
mount -a in een simulatiemodus uitvoeren of een testkoppeling maken om alles te valideren voordat je opnieuw opstart

Controleer na het schrijven van de vermelding altijd met findmnt --verify (beschikbaar op moderne distributies met systemd) om syntaxisfouten direct te vinden.

#!/usr/bin/env bash
# Safely append a new entry to /etc/fstab (idempotent)
set -euo pipefail

DEVICE_PATH='/dev/sdb1'
MOUNTPOINT='/mnt/data'
FSTYPE='ext4'
OPTIONS='defaults,nofail'
FSTAB='/etc/fstab'

# Resolve UUID for stable identification
UUID=$(sudo blkid -s UUID -o value "$DEVICE_PATH")
if [[ -z "$UUID" ]]; then
  echo "ERROR: Could not resolve UUID for $DEVICE_PATH" >&2
  exit 1
fi

ENTRY="UUID=$UUID  $MOUNTPOINT  $FSTYPE  $OPTIONS  0  2"

# Idempotency: skip if UUID already referenced in fstab
if grep -qsF "UUID=$UUID" "$FSTAB"; then
  echo "INFO: fstab already contains UUID=$UUID — skipping."
  exit 0
fi

# Backup
cp -p "$FSTAB" "${FSTAB}.bak.$(date +%Y%m%d%H%M%S)"

# Create mountpoint if needed
sudo mkdir -p "$MOUNTPOINT"

# Append entry
echo "$ENTRY" | sudo tee -a "$FSTAB" > /dev/null
echo "INFO: Added: $ENTRY"

# Validate
sudo findmnt --verify --verbose || echo 'WARNING: findmnt verify reported issues'

Bestandssystemen koppelen en ontkoppelen in scripts

De opdrachten mount en umount zijn eenvoudig, maar scripts moeten uitzonderingssituaties afhandelen:

Een apparaat kan al gekoppeld zijn — opnieuw koppelen mislukt; controleer dit met findmnt of mountpoint
Een koppelpunt kan bezet zijn (door geopende bestanden) — umount mislukt; gebruik lsof +D /mnt/target om de boosdoeners te vinden
Gebruik mount -o remount,ro /mnt/data om over te schakelen naar alleen-lezen zonder het bestandssysteem te ontkoppelen
Gebruik umount -l /mnt/data (lazy) alleen als laatste redmiddel — dit koppelt de naamruimte los, maar wacht totdat verwijzingen zijn gesloten

Controleer bij automatisering altijd de afsluitcode van mount en log fouten naar syslog met logger.

#!/usr/bin/env bash
# Mount a device only if not already mounted; log outcome
set -euo pipefail

DEVICE='/dev/sdb1'
MOUNTPOINT='/mnt/data'

log() { logger -t disk-mount "$*"; echo "[$(date '+%F %T')] $*"; }

# Check if already mounted
if mountpoint -q "$MOUNTPOINT"; then
  log "INFO: $MOUNTPOINT is already mounted — nothing to do."
  exit 0
fi

# Ensure mountpoint directory exists
sudo mkdir -p "$MOUNTPOINT"

# Attempt mount
if sudo mount "$DEVICE" "$MOUNTPOINT"; then
  log "OK: Mounted $DEVICE at $MOUNTPOINT"
else
  log "ERROR: Failed to mount $DEVICE at $MOUNTPOINT"
  exit 1
fi

# Show what is now mounted there
df -h "$MOUNTPOINT"

Inleiding tot LVM: fysieke volumes, volumegroepen en logische volumes

LVM (Logical Volume Manager) voegt een flexibele abstractielaag toe tussen onbewerkte blokapparaten en bestandssystemen. De hiërarchie met drie niveaus is:

Physical Volume (PV) — een onbewerkte schijf of partitie die is geïnitialiseerd met pvcreate
Volume Group (VG) — een of meer PV's die met vgcreate zijn samengevoegd
Logical Volume (LV) — een virtuele partitie die met lvcreate uit een VG is gemaakt; dit is wat je formatteert en koppelt

Het belangrijkste voordeel: je kunt een LV online uitbreiden zonder het te ontkoppelen en nieuwe schijven aan een VG toevoegen zonder opnieuw te formatteren. Daardoor is LVM onmisbaar voor automatisering van opslag in productieomgevingen.

Opdrachten voor inspectie: pvs, vgs, lvs en de uitgebreide varianten pvdisplay, vgdisplay, lvdisplay.

Het aanmaken van LVM-volumes scripten

Het automatiseren van LVM-configuratie volgt een vaste volgorde: pvcreate → vgcreate → lvcreate → mkfs → mount. Elke stap moet slagen voordat de volgende wordt uitgevoerd — gebruik set -euo pipefail en valideer de uitvoer van elke opdracht.

Controleer altijd of de doelschijf geen bestaande partitietabel heeft voordat je pvcreate uitvoert
Gebruik de optie -y om interactieve vragen in niet-interactieve scripts te onderdrukken
Geef -L (vaste grootte) of -l 100%FREE op voor alle resterende ruimte
Gebruik na mkfs het apparaatpad van de LV: /dev/<vgname>/<lvname>

#!/usr/bin/env bash
# Automate LVM setup: PV -> VG -> LV -> mkfs -> mount
set -euo pipefail

DISK='/dev/sdc'          # raw disk, no existing partitions
VG_NAME='vg_appdata'
LV_NAME='lv_appdata'
LV_SIZE='10G'
MOUNTPOINT='/mnt/appdata'
FSTYPE='xfs'

echo "[1/6] Initializing Physical Volume on $DISK"
sudo pvcreate -y "$DISK"

echo "[2/6] Creating Volume Group: $VG_NAME"
sudo vgcreate "$VG_NAME" "$DISK"

echo "[3/6] Creating Logical Volume: $LV_NAME (${LV_SIZE})"
sudo lvcreate -y -L "$LV_SIZE" -n "$LV_NAME" "$VG_NAME"

echo "[4/6] Formatting as $FSTYPE"
sudo mkfs."$FSTYPE" "/dev/$VG_NAME/$LV_NAME"

echo "[5/6] Mounting at $MOUNTPOINT"
sudo mkdir -p "$MOUNTPOINT"
sudo mount "/dev/$VG_NAME/$LV_NAME" "$MOUNTPOINT"

echo "[6/6] Done. Disk usage:"
df -h "$MOUNTPOINT"

# Show LVM summary
vgs && lvs

Een logisch volume online uitbreiden

Een van de krachtigste functies van LVM is online vergroten — een logisch volume en het bijbehorende bestandssysteem uitbreiden terwijl het gekoppeld en in gebruik is. De werkwijze is:

Breid de LV uit met lvextend (met de optie -r wordt het bestandssysteem in dezelfde stap vergroot)
Als je -r niet gebruikt, vergroot je het bestandssysteem afzonderlijk: resize2fs voor ext4 en xfs_growfs voor xfs

Belangrijke beperkingen:

xfs kan alleen groeien en nooit krimpen — plan de capaciteit zorgvuldig
ext4 kan krimpen, maar alleen wanneer het ontkoppeld is
Controleer altijd met vgdisplay -s of de VG vrije ruimte heeft voordat je deze uitbreidt

#!/usr/bin/env bash
# Extend an LV and its xfs filesystem online
set -euo pipefail

VG_NAME='vg_appdata'
LV_NAME='lv_appdata'
EXTEND_BY='5G'
LV_DEV="/dev/$VG_NAME/$LV_NAME"

# Confirm VG has enough free space
FREE_GB=$(vgs --noheadings --units g -o vg_free "$VG_NAME" | tr -d ' g')
echo "VG free space: ${FREE_GB}G"
if (( $(echo "$FREE_GB < 5" | bc -l) )); then
  echo 'ERROR: Not enough free space in VG' >&2
  exit 1
fi

echo "Extending LV by $EXTEND_BY..."
sudo lvextend -L "+${EXTEND_BY}" "$LV_DEV"

echo 'Growing xfs filesystem online...'
sudo xfs_growfs "$LV_DEV"

echo 'New size:'
df -h "$LV_DEV"
lvs "$LV_DEV"

Bestandssystemen aanmaken en formatteren

Na het partitioneren of configureren van LVM moet je het blokapparaat formatteren met een bestandssysteem. Veelgebruikte keuzes voor Linux-beheer:

ext4 — volwassen, voorzien van journaling en geschikt om te verkleinen; standaard op veel distributies (mkfs.ext4)
xfs — hoge prestaties, geschikt voor grote bestanden en parallelle I/O; standaard op RHEL/CentOS (mkfs.xfs)
btrfs — copy-on-write, met ingebouwde momentopnamen (mkfs.btrfs)
tmpfs — gebaseerd op RAM, opgegeven in fstab zonder mkfs

Stel altijd een betekenisvol bestandssysteemp label in (optie -L), zodat je in fstab naar het apparaat kunt verwijzen met LABEL= als alternatief voor UUID.

#!/usr/bin/env bash
# Format a partition and assign a label; print resulting UUID
set -euo pipefail

PARTITION='/dev/sdb1'
FSTYPE='ext4'
LABEL='appdata'

# Safety check: refuse to format a currently mounted device
if findmnt --source "$PARTITION" > /dev/null 2>&1; then
  echo "ERROR: $PARTITION is currently mounted. Unmount first." >&2
  exit 1
fi

echo "Formatting $PARTITION as $FSTYPE with label '$LABEL'..."
sudo mkfs."$FSTYPE" -L "$LABEL" -F "$PARTITION"

# Retrieve and display the new UUID
NEW_UUID=$(sudo blkid -s UUID -o value "$PARTITION")
echo "Formatted successfully."
echo "Label : $LABEL"
echo "UUID  : $NEW_UUID"
echo "Use this in fstab: UUID=$NEW_UUID  /mnt/$LABEL  $FSTYPE  defaults,nofail  0  2"

NFS-koppelingen automatiseren met autofs

Bij netwerkbestandssystemen kan koppelen tijdens het opstarten met fstab vertragingen of fouten veroorzaken als de NFS-server tijdelijk niet bereikbaar is. autofs lost dit op door op verzoek te koppelen en na een time-out weer te ontkoppelen.

Hoofdkaart: /etc/auto.master — definieert de map voor het koppelpunt en het bijbehorende kaartbestand
Directe kaart: /etc/auto.nfs — geeft per submap de opties en het pad naar de NFS-server op
Laad de configuratie na wijzigingen opnieuw met systemctl reload autofs
Koppelingen verschijnen automatisch onder de geconfigureerde map wanneer deze wordt benaderd

In scripts kun je het kaartbestand dynamisch genereren uit een lijst met NFS-gedeelde mappen en autofs opnieuw laden — handig voor het beschikbaar stellen van gedeelde opslag op veel hosts.

#!/usr/bin/env bash
# Generate an autofs NFS map file from a share list and reload autofs
set -euo pipefail

NFS_SERVER='192.168.1.50'
AUTO_MAP='/etc/auto.nfs'
AUTO_MASTER='/etc/auto.master'
MOUNT_BASE='/nfs'

# Define shares: localname:remote_path
declare -A SHARES=(
  [homes]='/export/homes'
  [media]='/export/media'
  [backups]='/export/backups'
)

# Write map file
{
  echo '# Generated by disk-automation script'
  for localname in "${!SHARES[@]}"; do
    remote="${SHARES[$localname]}"
    echo "$localname  -rw,soft,timeo=30  ${NFS_SERVER}:${remote}"
  done
} | sudo tee "$AUTO_MAP" > /dev/null

echo "Wrote $AUTO_MAP"

# Ensure master map references this file
if ! grep -qF "$AUTO_MAP" "$AUTO_MASTER"; then
  echo "$MOUNT_BASE  $AUTO_MAP" | sudo tee -a "$AUTO_MASTER" > /dev/null
  echo "Updated $AUTO_MASTER"
fi

sudo systemctl reload autofs && echo 'autofs reloaded'

LVM-momentopnamen voor veilige back-ups

LVM-momentopnamen bieden een kopie van een logisch volume op een bepaald tijdstip. Zo kun je consistente back-ups van actieve bestandssystemen maken zonder ze te ontkoppelen. De momentopname legt de toestand op het moment van aanmaken vast met copy-on-write.

Aanmaken: lvcreate -s -n lv_snap -L 2G /dev/vg_data/lv_data
Koppel de momentopname alleen-lezen om er een back-up van te maken: mount -o ro /dev/vg_data/lv_snap /mnt/snap
Voer rsync of tar uit op het koppelpunt van de momentopname
Verwijder de momentopname na de back-up: umount /mnt/snap && lvremove -f /dev/vg_data/lv_snap

Houd de grootte van de momentopname op 10–20% van de oorspronkelijke LV. Als de momentopname vol raakt, wordt deze ongeldig — controleer dit met lvs -o lv_name,snap_percent.

#!/usr/bin/env bash
# Create an LVM snapshot, back up via tar, then remove snapshot
set -euo pipefail

VG='vg_appdata'
ORIGIN_LV='lv_appdata'
SNAP_LV='lv_appdata_snap'
SNAP_SIZE='2G'
SNAP_MOUNT='/mnt/snap_backup'
BACKUP_DEST='/var/backups/appdata'
DATESTAMP=$(date +%Y%m%d_%H%M%S)

trap 'sudo umount "$SNAP_MOUNT" 2>/dev/null; sudo lvremove -f "/dev/$VG/$SNAP_LV" 2>/dev/null' ERR EXIT

echo '[1] Creating snapshot...'
sudo lvcreate -s -n "$SNAP_LV" -L "$SNAP_SIZE" "/dev/$VG/$ORIGIN_LV"

echo '[2] Mounting snapshot read-only...'
sudo mkdir -p "$SNAP_MOUNT"
sudo mount -o ro "/dev/$VG/$SNAP_LV" "$SNAP_MOUNT"

echo '[3] Archiving to backup destination...'
sudo mkdir -p "$BACKUP_DEST"
sudo tar -czf "$BACKUP_DEST/appdata_${DATESTAMP}.tar.gz" -C "$SNAP_MOUNT" .

echo '[4] Cleaning up snapshot...'
sudo umount "$SNAP_MOUNT"
sudo lvremove -f "/dev/$VG/$SNAP_LV"

echo "Backup complete: $BACKUP_DEST/appdata_${DATESTAMP}.tar.gz"

Kennistoets: veilige automatisering van fstab en koppelingen

Test je inzicht in de veilige werkwijzen voor het automatiseren van schijven, bestandssystemen en koppelingen die in deze les zijn behandeld.

Beantwoord dit in de interactieve les

Samenvatting van de les: automatisering van schijven, bestandssystemen en koppelingen

In deze les heb je een complete gereedschapsset opgebouwd voor veilig, scriptbaar beheer van schijven en opslag op Linux-systemen. De belangrijkste punten:

Eerst inspecteren: met lsblk, blkid, df en du verzamel je de informatie die je vóór elke wijziging nodig hebt.
Discipline bij fstab: gebruik altijd UUID, neem altijd nofail op, maak altijd een back-up voordat je bewerkt en valideer met findmnt --verify.
Veilig koppelen: controleer vóór het koppelen mountpoint -q, log met logger en handel fouten door bezette apparaten af met lsof.
De kracht van LVM: de PV → VG → LV-pijplijn maakt online uitbreiden en back-ups op basis van momentopnamen mogelijk zonder uitvaltijd.
De keuze van het bestandssysteem is belangrijk: xfs voor prestaties (kan alleen groeien), ext4 voor flexibiliteit (kan offline krimpen) en btrfs voor werklasten met native ondersteuning voor momentopnamen.
NFS op verzoek: autofs voorkomt vertragingen tijdens het opstarten door netwerkgedeelde mappen alleen te koppelen wanneer ze worden benaderd.
Back-ups met momentopnamen: LVM-momentopnamen leveren consistente back-ups van actieve gegevens — maar controleer altijd snap_percent en verwijder momentopnamen direct na de back-up.

Combineer deze patronen en je kunt de volledige opslaglevenscyclus betrouwbaar automatiseren: inventariseren, beschikbaar stellen, koppelen, vergroten en back-uppen.

Gratis beginnen

Leer DevOps-bootcamp met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 142
Lessen: 568

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Schijven, bestandssystemen en mountbewerkingen automatiseren” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad DevOps-bootcamp, waaronder “Schijven, bestandssystemen en mountbewerkingen automatiseren”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus DevOps-bootcamp bevat in totaal 4 lessen.

Wat leer ik in “Schijven, bestandssystemen en mountbewerkingen automatiseren”?

Inspecteer block devices, beheer fstab-vermeldingen en automatiseer LVM- en mountbewerkingen veilig. Je oefent met DevOps-bootcamp door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met DevOps-bootcamp te beginnen?

Ervaring vooraf is niet nodig. DevOps-bootcamp op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Schijven, bestandssystemen en mountbewerkingen automatiseren”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over DevOps-bootcamp?

Ja. Elke les over DevOps-bootcamp bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Gebruikers en groepen automatisch configureren
systemd-services beheren en unitbestanden schrijven
Schijven, bestandssystemen en mountbewerkingen automatiseren
Scripts voor systeemcontroles en waarschuwingen bouwen

← Terug naar DevOps-bootcamp