DevOps Bootcamp · Lektion

Datenträger-, Dateisystem- und Mount-Automatisierung

Untersuchen Sie Blockgeräte, verwalten Sie fstab-Einträge und automatisieren Sie LVM- und Mount-Vorgänge sicher per Skript.

Lektion 3 von 413 Schritte

Datenträger-, Dateisystem- und Mount-Automatisierung ist eine kostenlose DevOps Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des DevOps Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Blockgeräte mit lsblk und fdisk verstehen

Bevor Sie Festplattenvorgänge automatisieren, müssen Sie prüfen können, welche Blockgeräte auf dem System vorhanden sind. Zwei wichtige Werkzeuge dafür sind lsblk und fdisk -l.

lsblk — listet Blockgeräte in einer Baumstruktur auf und zeigt Gerätenamen, Größen, Einhängepunkte und Typen (disk, part, lvm) an
fdisk -l — zeigt Partitionstabellen und Sektordetails an (erfordert Root-Rechte)
blkid — gibt UUIDs und Dateisystemtypen für jedes Blockgerät aus

In Skripten müssen Sie diese Ausgabe häufig auswerten, um verfügbare Datenträger zu erkennen, zu prüfen, ob eine Partition formatiert ist, oder vor dem Einhängen ihre UUID zu ermitteln.

#!/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

Festplattenspeicher mit df und du prüfen

df und du sind die wichtigsten Werkzeuge zum Ermitteln der Belegung von Dateisystemen und Verzeichnissen. In Systemadministrationsskripten verwenden Sie sie, um Warnungen auszulösen, Kontingente durchzusetzen oder zu entscheiden, wann zusätzlicher Speicher bereitgestellt werden muss.

df -h — menschenlesbare Dateisystembelegung für alle eingehängten Dateisysteme
df -BG — Ausgabe in Gigabyte für eine konsistente numerische Verarbeitung
du -sh /path — zusammengefasste Größe eines bestimmten Verzeichnisses
du -d 1 /var — Aufschlüsselung bis in die erste Unterverzeichnisebene (nützlich, um große Unterverzeichnisse zu finden)

Die Spalte percent used aus df wird häufig ausgewertet, um in Überwachungsskripten Warnungen bei voller Festplatte auszulösen.

#!/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 lesen und auswerten

/etc/fstab ist die statische Dateisystemtabelle — sie legt fest, welche Geräte beim Systemstart an welchem Pfad und mit welchen Optionen eingehängt werden. Jede Zeile enthält sechs Felder:

Device — UUID=..., LABEL=... oder /dev/sdX
Mount point — Verzeichnispfad
Filesystem type — ext4, xfs, nfs, tmpfs usw.
Options — defaults, ro, noexec, nofail usw.
Dump — 0 oder 1 (Sicherungsoption)
Pass — 0, 1 oder 2 (Reihenfolge für fsck)

Skripte, die fstab-Einträge hinzufügen oder validieren, müssen Kommentare (Zeilen, die mit # beginnen) und leere Zeilen problemlos verarbeiten. Verwenden Sie immer bevorzugt UUIDs statt Gerätenamen, damit ein Neustart auch dann funktioniert, wenn sich die Reihenfolge der Geräte ändert.

#!/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"

Sicheres Hinzufügen eines fstab-Eintrags

Das manuelle Bearbeiten von /etc/fstab ist fehleranfällig. Ein fehlerhafter Eintrag kann den Systemstart verhindern. Ein sicheres Automatisierungsskript sollte:

Vor dem Anhängen prüfen, ob der Eintrag bereits vorhanden ist (Idempotenz)
Vor jeder Änderung eine Sicherung der Originaldatei erstellen
UUID statt eines Gerätepfads verwenden
nofail zu den Mount-Optionen hinzufügen, damit ein fehlendes Laufwerk den Systemstart nicht anhält
mount -a im Probelauf oder als Test-Mount ausführen, um die Konfiguration vor einem Neustart zu validieren

Überprüfen Sie den Eintrag nach dem Schreiben immer mit findmnt --verify (in modernen systemd-Distributionen verfügbar), um Syntaxfehler sofort zu erkennen.

#!/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'

Dateisysteme in Skripten ein- und aushängen

Die Befehle mount und umount sind unkompliziert, aber Skripte müssen Sonderfälle behandeln:

Ein Gerät ist möglicherweise bereits eingehängt — ein erneutes Einhängen schlägt fehl; prüfen Sie dies mit findmnt oder mountpoint
Ein Mountpoint ist möglicherweise belegt (geöffnete Dateien) — umount schlägt fehl; verwenden Sie lsof +D /mnt/target, um die verursachenden Prozesse zu finden
Verwenden Sie mount -o remount,ro /mnt/data, um ohne Aushängen in den Nur-Lese-Modus zu wechseln
Verwenden Sie umount -l /mnt/data (lazy) nur als letzten Ausweg — dadurch wird der Namespace getrennt, aber auf das Schließen der Referenzen gewartet

Prüfen Sie in der Automatisierung immer den Exit-Code von mount und protokollieren Sie Fehler mit logger im Syslog.

#!/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"

Einführung in LVM: Physical Volumes, Volume Groups und Logical Volumes

LVM (Logical Volume Manager) fügt zwischen rohen Blockgeräten und Dateisystemen eine flexible Abstraktionsebene ein. Die Hierarchie besteht aus drei Ebenen:

Physical Volume (PV) — eine mit pvcreate initialisierte Festplatte oder Partition
Volume Group (VG) — ein oder mehrere mit vgcreate zu einem Pool zusammengefasste PVs
Logical Volume (LV) — eine mit lvcreate aus einer VG erzeugte virtuelle Partition; sie wird formatiert und eingehängt

Der entscheidende Vorteil: Sie können ein LV im laufenden Betrieb erweitern, ohne es auszuhängen, und neue Festplatten zu einer VG hinzufügen, ohne sie neu zu formatieren. Dadurch ist LVM für die Automatisierung von Speicher in Produktionsumgebungen unverzichtbar.

Befehle zur Inspektion: pvs, vgs, lvs sowie ihre ausführlichen Varianten pvdisplay, vgdisplay und lvdisplay.

Erstellen von LVM-Volumes per Skript

Die Automatisierung der LVM-Einrichtung folgt einer festen Reihenfolge: pvcreate → vgcreate → lvcreate → mkfs → mount. Jeder Schritt muss erfolgreich abgeschlossen sein, bevor der nächste ausgeführt wird — verwenden Sie set -euo pipefail und validieren Sie die Ausgabe jedes Befehls.

Prüfen Sie immer, dass die Zielfestplatte keine vorhandene Partitionstabelle enthält, bevor Sie pvcreate aufrufen
Verwenden Sie in nicht interaktiven Skripten das Flag -y, um interaktive Eingabeaufforderungen zu unterdrücken
Geben Sie -L (feste Größe) oder -l 100%FREE für den gesamten verbleibenden Speicherplatz an
Verwenden Sie nach mkfs den Gerätepfad des 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

Ein Logical Volume im laufenden Betrieb erweitern

Eine der leistungsfähigsten Funktionen von LVM ist die Online-Größenänderung — ein Logical Volume und sein Dateisystem können erweitert werden, während sie eingehängt und in Gebrauch sind. Der Ablauf ist:

Erweitern Sie das LV mit lvextend (das Flag -r ändert die Größe des Dateisystems im selben Schritt)
Wenn Sie -r nicht verwenden, ändern Sie die Größe des Dateisystems separat: resize2fs für ext4, xfs_growfs für xfs

Wichtige Einschränkungen:

xfs kann nur vergrößert, niemals verkleinert werden — planen Sie die Kapazität sorgfältig
ext4 kann verkleinert werden, jedoch nur im ausgehängten Zustand
Prüfen Sie vor dem Erweitern immer mit vgdisplay -s, ob in der VG freier Speicherplatz vorhanden ist

#!/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"

Dateisysteme erstellen und formatieren

Nach der Partitionierung oder der Einrichtung von LVM müssen Sie das Blockgerät mit einem Dateisystem formatieren. Übliche Optionen in der Linux-Administration:

ext4 — ausgereift, journalingfähig und verkleinerbar; in vielen Distributionen der Standard (mkfs.ext4)
xfs — leistungsstark und für große Dateien sowie parallele I/O bevorzugt; Standard bei RHEL/CentOS (mkfs.xfs)
btrfs — Copy-on-Write mit integrierten Snapshots (mkfs.btrfs)
tmpfs — RAM-basiert und wird in fstab ohne mkfs angegeben

Vergeben Sie immer ein aussagekräftiges Dateisystem-Label (Flag -L), damit das Gerät in fstab alternativ zur UUID über LABEL= referenziert werden kann.

#!/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-Mounts mit autofs automatisieren

Bei Netzwerkdateisystemen kann das Einhängen beim Systemstart über fstab zu Verzögerungen oder Fehlern führen, wenn der NFS-Server vorübergehend nicht erreichbar ist. autofs löst dieses Problem, indem es Dateisysteme bei Bedarf einhängt und nach einer Zeitüberschreitung wieder aushängt.

Master-Map: /etc/auto.master — definiert das Verzeichnis für den Mountpoint und dessen Map-Datei
Direkte Map: /etc/auto.nfs — gibt Optionen und den Pfad des NFS-Servers für jedes Unterverzeichnis an
Laden Sie die Konfiguration nach Änderungen mit systemctl reload autofs neu
Mounts erscheinen automatisch unter dem konfigurierten Verzeichnis, sobald darauf zugegriffen wird

In Skripten können Sie die Map-Datei aus einer Liste von NFS-Freigaben dynamisch erzeugen und autofs neu laden — dies ist nützlich, um gemeinsamen Speicher auf vielen Hosts bereitzustellen.

#!/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-Snapshots für sichere Backups

LVM-Snapshots stellen eine zeitpunktbezogene Kopie eines Logical Volume bereit und ermöglichen konsistente Backups aktiver Dateisysteme, ohne diese auszuhängen. Der Snapshot erfasst den Zustand zum Zeitpunkt seiner Erstellung mithilfe von Copy-on-Write.

Erstellen: lvcreate -s -n lv_snap -L 2G /dev/vg_data/lv_data
Hängen Sie den Snapshot zum Sichern schreibgeschützt ein: mount -o ro /dev/vg_data/lv_snap /mnt/snap
Führen Sie rsync oder tar für den Mountpoint des Snapshots aus
Snapshot nach dem Backup entfernen: umount /mnt/snap && lvremove -f /dev/vg_data/lv_snap

Halten Sie die Größe des Snapshots bei 10–20 % des ursprünglichen LV. Wenn der Snapshot voll läuft, wird er ungültig — überwachen Sie ihn mit 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"

Wissenscheck: Sichere Automatisierung von fstab und Mounts

Testen Sie Ihr Verständnis der in dieser Lektion behandelten Verfahren zur sicheren Automatisierung von Datenträgern, Dateisystemen und Mounts.

Beantworte es in der interaktiven Lektion

Lektionsrückblick: Automatisierung von Datenträgern, Dateisystemen und Mounts

In dieser Lektion haben Sie ein vollständiges Werkzeugset für die sichere, skriptgesteuerte Verwaltung von Datenträgern und Speicher auf Linux-Systemen erstellt. Die wichtigsten Erkenntnisse:

Erst inspizieren: lsblk, blkid, df und du liefern die erforderlichen Informationen vor jeder Änderung.
Disziplin bei fstab: Verwenden Sie immer UUID, nehmen Sie immer nofail auf, erstellen Sie vor der Bearbeitung immer eine Sicherung und validieren Sie mit findmnt --verify.
Sicherheit beim Mounten: Prüfen Sie vor dem Einhängen mountpoint -q, protokollieren Sie mit logger und behandeln Sie Fehler aufgrund belegter Geräte mit lsof.
Die Stärken von LVM: Die Pipeline PV → VG → LV ermöglicht Erweiterungen im laufenden Betrieb und Snapshot-basierte Backups ohne Ausfallzeit.
Die Wahl des Dateisystems ist entscheidend: xfs für Leistung (nur vergrößerbar), ext4 für Flexibilität (offline verkleinerbar), btrfs für Snapshot-native Workloads.
NFS nach Bedarf: autofs vermeidet Verzögerungen beim Systemstart, indem Netzwerkfreigaben erst bei Zugriff eingehängt werden.
Snapshot-Backups: LVM-Snapshots liefern konsistente Backups im laufenden Betrieb — überwachen Sie jedoch immer snap_percent und entfernen Sie Snapshots nach dem Backup zeitnah.

Wenn Sie diese Muster kombinieren, können Sie den gesamten Speicherlebenszyklus zuverlässig automatisieren: Erkennung, Bereitstellung, Einhängen, Größenänderung und Sicherung.

Kostenlos starten

Lerne DevOps Bootcamp mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 142
Lektionen: 568

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Datenträger-, Dateisystem- und Mount-Automatisierung“ kostenlos?

Ja — der vollständige Text von „Datenträger-, Dateisystem- und Mount-Automatisierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DevOps Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Datenträger-, Dateisystem- und Mount-Automatisierung“?

Untersuchen Sie Blockgeräte, verwalten Sie fstab-Einträge und automatisieren Sie LVM- und Mount-Vorgänge sicher per Skript. Du übst DevOps Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um DevOps Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. DevOps Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Datenträger-, Dateisystem- und Mount-Automatisierung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser DevOps Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede DevOps Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Bereitstellung von Benutzern und Gruppen automatisieren
systemd-Dienste steuern und Unit-Dateien schreiben
Datenträger-, Dateisystem- und Mount-Automatisierung
Skripte für Systemprüfungen und Warnmeldungen erstellen

← Zurück zu DevOps Bootcamp