Die Linux-Festplattenpartitionierung ist eine grundlegende Fähigkeit für jeden Systemadministrator oder DevOps-Ingenieur. Ob du eine Datenfestplatte zu einem Server hinzufügst, eine neue Installation einrichtest oder Speicher für eine Datenbank vorbereitest — das Wissen, wie man Festplatten mit fdisk und parted partitioniert und wie man Einhängepunkte in /etc/fstab mit UUIDs dauerhaft einträgt, bewahrt dich vor kostspieligen Fehlern und Ausfallzeiten. Diese Anleitung deckt den gesamten Ablauf von der rohen Festplatte bis zum eingehängten, automatisch einbindenden Dateisystem ab.

Voraussetzungen

  • Root- oder sudo-Zugang auf einem Linux-System
  • Eine rohe oder virtuelle Festplatte, die am Rechner angeschlossen ist (z. B. /dev/sdb)
  • Grundkenntnisse im Umgang mit dem Linux-Terminal
  • Paket util-linux installiert (stellt fdisk, lsblk, blkid bereit — standardmäßig auf den meisten Distributionen vorhanden)
  • parted installiert: apt install parted oder dnf install parted

MBR vs. GPT: Die richtige Partitionstabelle wählen

Bevor du eine Festplatte anfasst, musst du entscheiden, welches Partitionstabellenformat du verwenden möchtest. Die beiden Standards sind MBR (Master Boot Record) und GPT (GUID Partition Table).

MerkmalMBRGPT
Maximale Festplattengröße2 TB9,4 ZB (praktisch unbegrenzt)
Maximale primäre Partitionen4 (oder 3 primär + erweitert)128
Boot-FirmwareBIOSUEFI (funktioniert auch mit BIOS über Hybrid)
RedundanzKeineBackup-Header am Ende der Festplatte
Betriebssystem-UnterstützungAlle Linux, Windows XP+Linux-Kernel 2.6.25+, Windows Vista+, macOS
Werkzeug-Unterstützungfdisk, parted, gdiskparted, gdisk, fdisk (seit util-linux 2.23)
WiederherstellungSchwierigerBackup-GPT-Header ermöglicht Wiederherstellung

Faustregel: Verwende GPT für jede neue Festplatte. Das 128-Partitionen-Limit von GPT, die Ausfallsicherheit durch den Backup-Header und das Fehlen der 2-TB-Grenze machen es zur richtigen Standardwahl. Verwende MBR nur, wenn du sehr alte Systeme oder eingebettete Hardware anvisierst, die es ausdrücklich erfordert.

Partitionierung mit fdisk

fdisk ist ein interaktives, menügeführtes Werkzeug aus dem util-linux-Paket. Moderne Versionen (util-linux 2.23+) unterstützen GPT und machen es zu einer flexiblen Wahl für die meisten Aufgaben.

Vorhandene Festplatten untersuchen

# Alle Blockgeräte mit Größen und Typen auflisten
lsblk

# Detaillierte Partitionsinformationen anzeigen
fdisk -l

# Eine bestimmte Festplatte anzeigen
fdisk -l /dev/sdb

GPT-Partition mit fdisk erstellen

sudo fdisk /dev/sdb

Im interaktiven Prompt:

Command (m for help): g        # Neue GPT-Partitionstabelle erstellen (für MBR 'o' verwenden)
Created a new GPT disklabel (GUID: ...).

Command (m for help): n        # Neue Partition
Partition number (1-128, default 1): 1
First sector (2048-..., default 2048): [Enter]
Last sector, +/-sectors or +/-size{K,M,G,T,P}: +100G   # Partitionsgröße festlegen

Command (m for help): t        # Partitionstyp ändern (optional)
Selected partition 1
Partition type or alias (type L to list all): 20   # Linux-Dateisystem

Command (m for help): p        # Partitionstabelle vor dem Schreiben prüfen

Command (m for help): w        # Änderungen schreiben und beenden

Nach dem Schreiben wird der Kernel benachrichtigt. Falls nicht, führe partprobe /dev/sdb oder udevadm settle aus, um ein erneutes Einlesen zu erzwingen.

Wichtige fdisk-Befehle

TasteAktion
mHilfemenü anzeigen
gNeue GPT-Partitionstabelle
oNeue MBR-Partitionstabelle
nNeue Partition
dPartition löschen
tPartitionstyp ändern
pPartitionstabelle ausgeben
wSchreiben und beenden
qOhne Speichern beenden

Partitionierung mit parted

parted unterstützt sowohl MBR als auch GPT und ist skriptfähig — ideal für Automatisierungsskripte und Provisionierungswerkzeuge wie Ansible oder Terraform. Es verwaltet auch Festplatten größer als 2 TB problemlos.

Interaktiver Modus

sudo parted /dev/sdb
(parted) mklabel gpt                  # GPT-Partitionstabelle erstellen
(parted) mkpart primary ext4 0% 100%  # Einzelne Partition über die gesamte Festplatte
(parted) print                        # Überprüfen
(parted) quit

Nicht-interaktiver (skriptfähiger) Modus

# GPT-Tabelle erstellen
sudo parted -s /dev/sdb mklabel gpt

# Eine einzelne Partition mit 100% des Festplattenspeichers erstellen
sudo parted -s /dev/sdb mkpart primary ext4 0% 100%

# Zwei Partitionen erstellen: 50 GB Daten, Rest für Logs
sudo parted -s /dev/sdb mkpart primary ext4 0% 50GB
sudo parted -s /dev/sdb mkpart primary ext4 50GB 100%

Das Flag -s unterdrückt interaktive Eingabeaufforderungen und macht parted sicher für den Einsatz in der Automatisierung.

parted-Ausrichtung

Verwende immer prozentbasierte Grenzen (0%, 100%, 50%) oder MiB/GiB-Werte statt roher Sektornummern. Dies gewährleistet eine ordnungsgemäße 4K-Sektorausrichtung, die für SSD- und NVMe-Leistung wichtig ist.

# Ausrichtung nach dem Erstellen von Partitionen überprüfen
sudo parted /dev/sdb align-check optimal 1
# Ausgabe: 1 aligned

Partitionen mit mkfs formatieren

Nach dem Erstellen einer Partition muss ein Dateisystem darauf angelegt werden. Die Wahl des Dateisystems hängt von deiner Arbeitslast ab.

# ext4 — Allzweck, am kompatibelsten
sudo mkfs.ext4 /dev/sdb1

# xfs — Hochleistung, bevorzugt für große Dateien und Datenbanken
sudo mkfs.xfs /dev/sdb1

# btrfs — Copy-on-Write, Snapshots, Komprimierung
sudo mkfs.btrfs /dev/sdb1

# Label hinzufügen (macht fstab-Einträge lesbarer)
sudo mkfs.ext4 -L data /dev/sdb1
DateisystemAm besten fürMax. DateigrößeMax. Volume-Größe
ext4Allzweck, VM-Festplatten16 TB1 EB
xfsDatenbanken, große Dateien8 EB8 EB
btrfsSnapshots, NAS, Heimserver16 EB16 EB
vfat/FAT32USB-Laufwerke, EFI-Partitionen4 GB2 TB

Einbinden und dauerhafte Einbindung mit /etc/fstab

Eine manuell eingehängte Partition verschwindet nach einem Neustart. Um die Einbindung dauerhaft zu machen, füge sie in /etc/fstab ein. Verwende immer UUIDs statt Gerätenamen wie /dev/sdb1 — Gerätenamen können sich nach Neustarts oder beim Hinzufügen oder Entfernen von Festplatten ändern.

UUID ermitteln

sudo blkid /dev/sdb1
# Ausgabe: /dev/sdb1: UUID="a1b2c3d4-..." TYPE="ext4" PARTLABEL="primary"

# Alternative: alle Blockgeräte-UUIDs anzeigen
lsblk -o NAME,UUID,FSTYPE,SIZE,MOUNTPOINT

Einhängepunkt erstellen und sofort einbinden

sudo mkdir -p /mnt/data
sudo mount /dev/sdb1 /mnt/data

# Überprüfen
df -h /mnt/data

In /etc/fstab eintragen

Öffne /etc/fstab mit deinem Editor:

sudo nano /etc/fstab

Füge eine Zeile in diesem Format hinzu:

# <Gerät>                                <Einhängepunkt>  <Typ>  <Optionen>        <dump> <pass>
UUID=a1b2c3d4-e5f6-7890-abcd-ef1234567890  /mnt/data        ext4   defaults,nofail   0      2

Wichtige Optionen erklärt:

OptionBedeutung
defaultsrw, suid, dev, exec, auto, nouser, async
nofailSystemstart gelingt auch wenn die Festplatte fehlt (unerlässlich für Nicht-Root-Festplatten)
noatimeZugriffszeitenaktualisierungen überspringen — verbessert SSD-Lebensdauer und Leistung
0 (dump)0 = nicht sichern; 1 = in Dump-Sicherung einschließen
2 (pass)fsck-Reihenfolge: 0 = überspringen, 1 = nur Root, 2 = nach Root prüfen

fstab-Eintrag ohne Neustart überprüfen

# Zuerst aushängen
sudo umount /mnt/data

# fstab testen (hängt alle Einträge ein)
sudo mount -a

# Bestätigen
df -h /mnt/data

Wenn mount -a keine Fehler zurückgibt, ist der Eintrag gültig und übersteht einen Neustart.

Praxisszenario: Datenfestplatte zu einem Produktions-Webserver hinzufügen

Du hast einen Produktions-Webserver, der Ubuntu 22.04 ausführt. Die Root-Festplatte ist fast voll, weil /var/www auf 180 GB angewachsen ist. Du hängst eine neue 500-GB-SSD als /dev/sdb an und möchtest Webinhalte darauf verschieben, ohne Ausfallzeiten.

Schritt 1 — Neue Festplatte identifizieren und partitionieren:

lsblk
# /dev/sdb als neue 500-GB-Festplatte ohne Partitionen bestätigen

sudo parted -s /dev/sdb mklabel gpt
sudo parted -s /dev/sdb mkpart primary ext4 0% 100%
sudo partprobe /dev/sdb

Schritt 2 — Formatieren und beschriften:

sudo mkfs.ext4 -L webdata /dev/sdb1

Schritt 3 — Vorhandene Daten auf die neue Festplatte kopieren:

sudo mkdir /mnt/newwww
sudo mount /dev/sdb1 /mnt/newwww
sudo rsync -av --progress /var/www/ /mnt/newwww/

Schritt 4 — Einhängepunkt wechseln (mit minimaler Ausfallzeit):

sudo umount /mnt/newwww

# UUID ermitteln
sudo blkid /dev/sdb1

# /etc/fstab bearbeiten — neuen Einhängepunkt für /var/www hinzufügen
# UUID=xxxx-xxxx  /var/www  ext4  defaults,nofail,noatime  0  2

# Alte Daten beiseite schieben und neu einhängen
sudo mv /var/www /var/www.bak
sudo mkdir /var/www
sudo mount -a

# Prüfen, ob der Webserver Dateien lesen kann
ls /var/www

Schritt 5 — Validieren und aufräumen:

df -h /var/www
# /dev/sdb1  500G  180G  320G  36%  /var/www

# Nachdem alles funktioniert, Sicherung entfernen
sudo rm -rf /var/www.bak

Fallstricke und Sonderfälle

Gerätenamendrift: /dev/sdb kann nach einem Neustart zu /dev/sdc werden, wenn eine weitere Festplatte hinzugefügt wird. Verwende immer UUIDs in /etc/fstab und Skripten — niemals bloße Gerätepfade.

Partitionstabelle nicht sofort sichtbar: Nach dem Schreiben von Änderungen mit fdisk oder parted liest der Kernel die Partitionstabelle möglicherweise nicht sofort neu ein, wenn die Festplatte in Benutzung ist. Führe sudo partprobe /dev/sdb aus oder starte neu.

4K-Sektorausrichtung: Ältere Werkzeuge verwenden standardmäßig zylinderbasierte Ausrichtung, was zu Fehlausrichtungen auf modernen 4K-Sektorfestplatten führt. Verwende die prozentbasierte Syntax von parted oder die Standard-Sektorausrichtung von fdisk (2048 Sektoren = 1 MiB).

ext4 auf großen Festplatten: Für Volumes größer als 16 TB wechsle zu xfs. Der Befehl mkfs.ext4 gibt eine Warnung aus, die leicht zu übersehen ist.

Fehlendes nofail auf Nicht-Root-Festplatten: Ohne nofail führt eine fehlende sekundäre Festplatte dazu, dass das System beim Booten in den Notfallmodus wechselt. Füge nofail immer zu Nicht-Root-fstab-Einträgen hinzu.

GPT auf einem BIOS-System ohne BIOS-Boot-Partition: Bei der Verwendung von GPT mit GRUB auf einem Nicht-UEFI-System benötigst du eine kleine (1 MiB) unformatierte Partition mit dem Typ BIOS boot (Code ef02 in gdisk oder parted-Typ bios_grub). Ohne sie kann GRUB seine Stage 2 nicht installieren.

Fehlerbehebung

mount: /mnt/data: can't read superblock — Das Dateisystem wurde nicht erstellt, oder es wurde auf dem falschen Gerät erstellt. Führe file -s /dev/sdb1 aus, um zu prüfen, ob ein Dateisystem vorhanden ist.

mount: wrong fs type, bad option, bad superblock — Nichtübereinstimmung zwischen dem Dateisystemtyp in fstab und dem tatsächlichen Typ auf der Festplatte. Führe blkid /dev/sdb1 aus, um das Feld TYPE zu überprüfen und den fstab-Eintrag zu korrigieren.

WARNING: Re-reading the partition table failed — Der Kernel konnte seine Ansicht der Partitionstabelle nicht aktualisieren, weil die Festplatte beschäftigt ist. Wenn dies auf einer anderen Festplatte als der Boot-Festplatte passiert, führe partprobe aus oder starte neu.

UUID ändert sich nach mkfs — Jeder mkfs-Aufruf weist eine neue UUID zu. Wenn du eine Partition neu formatierst und /etc/fstab nicht aktualisierst, schlägt das Einhängen fehl. Führe immer blkid nach dem Formatieren aus und aktualisiere fstab sofort.

parted: Error: Partition(s) on /dev/sdb are being used — Eine oder mehrere Partitionen auf der Festplatte sind aktuell eingehängt. Hänge alle aus, bevor du neu beschriftest oder die Größe änderst.

Zusammenfassung

  • Wähle GPT für alle neuen Festplatten — es unterstützt 128 Partitionen, Festplatten über 2 TB und bietet einen Backup-Partitionstabellen-Header.
  • Verwende fdisk für interaktive Partitionierung; nutze parted wenn du Scripting, Automatisierung oder Festplatten größer als 2 TB benötigst.
  • Formatiere immer eine neue Partition mit mkfs vor dem Einbinden — eine rohe Partition hat kein Dateisystem.
  • Verwende UUID (keine Gerätenamen wie /dev/sdb1) in /etc/fstab, um sicherzustellen, dass Einbindungen eine Neuanordnung der Festplatten überstehen.
  • Füge nofail zu allen Nicht-Root-fstab-Einträgen hinzu, damit eine fehlende Festplatte das Systembooten nicht verhindert.
  • Überprüfe jede fstab-Änderung mit mount -a vor dem Neustart — ein fehlerhafter Eintrag kann das System unbootbar machen.
  • Richte Partitionen an MiB-Grenzen aus (prozentbasierte parted-Syntax oder fdisk-Standards) für optimale SSD- und NVMe-Leistung.

Verwandte Artikel