Linux-Dateisystem- und Festplattenverwaltung: Von den Grundlagen bis zu fortgeschrittenen Techniken

Einführung

Willkommen zu diesem Lab über Dateisystem- und Festplattenverwaltung unter Linux! Dieses Lab richtet sich an Anfänger, die gerade erst anfangen, die Welt der Linux-Systemadministration zu erkunden. Wir führen Sie durch die wichtigsten Befehle und Konzepte zur Verwaltung von Festplattenspeicher, zum Erstellen virtueller Festplatten und zur Wartung von Dateisystemen. Am Ende dieses Labs werden Sie praktische Erfahrungen mit grundlegenden Linux-Tools zur Festplattenverwaltung gesammelt haben.

Festplattennutzung mit df anzeigen

Der Befehl df (disk free) ist Ihr wichtigstes Werkzeug, um die Festplattennutzung auf Ihrem Linux-System zu überprüfen. Lassen Sie uns erkunden, wie man ihn verwendet:

Öffnen Sie Ihr Terminal. Sie sollten sich im Verzeichnis /home/labex/project befinden. Wenn Sie sich nicht sicher sind, können Sie Ihr aktuelles Verzeichnis jederzeit mit dem Befehl pwd überprüfen.
Führen Sie den folgenden Befehl aus, um die Festplattennutzung anzuzeigen:
```
df
```
Sie sehen eine Ausgabe, die in etwa so aussieht:
```
Filesystem     1K-blocks      Used Available Use% Mounted on
overlay         20971520    128744  20842776   1% /
tmpfs              65536         0     65536   0% /dev
tmpfs            3995004         0   3995004   0% /sys/fs/cgroup
shm                65536         0     65536   0% /dev/shm
/dev/nvme1n1  104806400  57754052  47052348  56% /etc/hosts
```
Keine Sorge, wenn das auf den ersten Blick verwirrend aussieht! Lassen Sie uns das aufschlüsseln:
- Filesystem: Diese Spalte zeigt den Namen der Festplatte oder Partition.
- 1K-blocks: Dies ist die Gesamtgröße des Dateisystems in 1-Kilobyte-Blöcken.
- Used: Dies zeigt an, wie viel Speicherplatz derzeit belegt ist.
- Available: Dies zeigt an, wie viel freier Speicherplatz noch übrig ist.
- Use%: Dies zeigt den Prozentsatz des Dateisystems an, der belegt ist.
- Mounted on: Dies zeigt an, an welcher Stelle im Verzeichnisbaum das Dateisystem eingehängt (gemountet) ist.

Lassen Sie uns diese Ausgabe nun für Menschen lesbarer machen. Führen Sie aus:

df -h

Die Option -h steht für "human-readable" (menschenlesbar). Sie sehen eine Ausgabe wie diese:

Filesystem      Size  Used Avail Use% Mounted on
overlay          20G  126M   20G   1% /
tmpfs            64M     0   64M   0% /dev
tmpfs           3.9G     0  3.9G   0% /sys/fs/cgroup
shm              64M     0   64M   0% /dev/shm
/dev/nvme1n1   100G   56G   45G  56% /etc/hosts

Viel besser, oder? Jetzt werden die Größen in GB und MB angegeben, was leichter zu verstehen ist.

Wenn Sie den Speicherplatz des Dateisystems überprüfen möchten, das eine bestimmte Datei oder ein Verzeichnis enthält, können Sie diesen Pfad an df übergeben:
```
df -h /etc/hosts
```
Dies zeigt Informationen nur für das Dateisystem an, das /etc/hosts enthält. In dieser Umgebung ist dieses Dateisystem normalerweise /dev/nvme1n1.

Der Befehl df ist unglaublich nützlich, um schnell zu überprüfen, wie viel Festplattenspeicher Sie noch haben. Wenn Sie jemals auf Probleme stoßen, bei denen Ihr System meldet, dass der Speicherplatz knapp wird, ist df oft der erste Befehl, den Sie zur Untersuchung verwenden.

Verzeichnisgrößen mit du untersuchen

Während df uns einen Überblick über die Festplattennutzung gibt, müssen wir manchmal tiefer graben. Hier kommt du (disk usage) ins Spiel. Es hilft uns zu verstehen, welche Verzeichnisse und Dateien den meisten Platz beanspruchen.

Beginnen wir mit der einfachsten Form von du. Führen Sie aus:
```
du ~
```
Sie sehen eine lange Liste von Zahlen und Verzeichnisnamen. Jede Zahl stellt die Größe des Verzeichnisses in Kilobyte dar. Das kann unübersichtlich sein, also lassen Sie uns das besser handhabbar machen.
Für eine lesbarere Ausgabe verwenden Sie die Option -h:
```
du -h ~
```
Die Option -h macht, genau wie bei df, die Ausgabe menschenlesbar. Sie sehen die Größen in KB, MB oder GB, je nachdem, was angemessen ist.
Oft möchten wir nur die Gesamtgröße eines Verzeichnisses wissen. Verwenden Sie dafür:
```
du -sh ~
```
Hier bedeutet -s "summarize" (zusammenfassen) und ~ steht für Ihr Home-Verzeichnis. Dieser Befehl zeigt Ihnen die Gesamtgröße aller Inhalte in Ihrem Home-Verzeichnis an.
Um die Größen der unmittelbaren Unterverzeichnisse in Ihrem Home-Verzeichnis anzuzeigen, verwenden Sie:
```
du -h --max-depth=1 ~
```
Dies zeigt die Größe jedes Unterverzeichnisses eine Ebene tief an. Die Option --max-depth=1 begrenzt, wie tief du in Unterverzeichnisse rekursiv absteigt.
Lassen Sie uns die Größe der Elemente in Ihrem Home-Verzeichnis überprüfen:
```
du -sh ~/*
```
Dies zeigt die Größe jeder nicht versteckten Datei und jedes Verzeichnisses direkt unter Ihrem Home-Verzeichnis an.
Hier ist ein leistungsstarker Befehl, um die größten Elemente in Ihrem Home-Verzeichnis zu finden:
```
du -h ~ | sort -rh | head -n 10
```
Lassen Sie uns das aufschlüsseln:
- du -h ~ listet alle Dateien und Verzeichnisse in Ihrem Home-Verzeichnis mit ihren Größen auf
- sort -rh sortiert diese Liste in umgekehrter Reihenfolge (die größten zuerst) und im menschenlesbaren Format
- head -n 10 zeigt nur die ersten 10 Zeilen der Ausgabe an
- | ist eine Pipe, die die Ausgabe eines Befehls als Eingabe an den nächsten weitergibt
Dieser Befehl ist ein großartiges Beispiel dafür, wie wir einfache Linux-Befehle kombinieren können, um komplexere Operationen durchzuführen.

Der Befehl du ist von unschätzbarem Wert, wenn Sie versuchen, Festplattenspeicher freizugeben. Er hilft Ihnen dabei, die Verzeichnisse oder Dateien zu identifizieren, die den meisten Platz beanspruchen, sodass Sie wissen, wo Sie mit Ihren Aufräumarbeiten ansetzen müssen.

Eine virtuelle Festplatte erstellen und verwalten

Bevor wir loslegen, lassen Sie uns verstehen, was eine virtuelle Festplatte ist. Eine virtuelle Festplatte ist einfach eine Datei, die wie ein physisches Festplattenlaufwerk fungiert. Stellen Sie es sich wie das Erstellen einer Container-Datei vor, die das Betriebssystem so behandeln kann, als wäre sie eine echte Festplatte. Dies ähnelt der Art und Weise, wie virtuelle Maschinen virtuelle Festplattendateien verwenden, um ihre Daten zu speichern.

Warum sollten wir das tun? Virtuelle Festplatten sind nützlich für:

Das sichere Testen von Festplattenoperationen, ohne echte Hardware zu gefährden
Das Erstellen isolierter Speicherbereiche
Das Erlernen der Festplattenverwaltung, ohne zusätzliche physische Hardware zu benötigen
Das Erstellen von Backup-Images echter Festplatten

Wichtige Konzepte verstehen

Bevor wir mit dem praktischen Teil fortfahren, lassen Sie uns einige wichtige Konzepte verstehen:

Dateisystem: Stellen Sie sich ein Dateisystem als die Art und Weise vor, wie Dateien und Ordner auf einer Festplatte organisiert sind. Es ist wie ein Ablagesystem in einem Büro – es bestimmt, wie Daten gespeichert und abgerufen werden. Gängige Linux-Dateisysteme sind ext4 (das wir verwenden werden), XFS und btrfs.
Mounten (Einhängen): Mounten ist der Prozess, ein Dateisystem für das Betriebssystem zugänglich zu machen. Wenn Sie ein Dateisystem mounten, sagen Sie Linux: "Stelle den Inhalt dieser Festplatte unter diesem bestimmten Verzeichnis zur Verfügung." Es ähnelt dem:
- Anschließen eines USB-Laufwerks (die physische Verbindung)
- Und dann dem Computer sagen, wo er dessen Inhalt anzeigen soll (der Mount-Point)
Partitionen: Eine Partition ist ein Abschnitt einer Festplatte, der als separate Einheit behandelt wird. Stellen Sie es sich wie die Unterteilung einer großen Festplatte in kleinere, unabhängige Abschnitte vor. Gründe für die Partitionierung sind:
- Trennung von Systemdateien und Benutzerdateien
- Verwendung unterschiedlicher Dateisysteme für verschiedene Zwecke
- Erleichterung von Backups
- Begrenzung der Auswirkungen von Festplattenfehlern

Lassen Sie uns eine virtuelle Festplatte erstellen und damit arbeiten:

Erstellen Sie zunächst eine 256 MB große virtuelle Festplatte mit dem Befehl dd:
```
dd if=/dev/zero of=virtual.img bs=1M count=256
```
Lassen Sie uns diesen Befehl aufschlüsseln:
- dd ist ein Dienstprogramm zum Kopieren und Konvertieren von Dateien
- if=/dev/zero bedeutet "Eingabedatei ist /dev/zero" (eine spezielle Datei, die endlose Nullen liefert)
- of=virtual.img bedeutet "Ausgabedatei ist virtual.img" (unsere neue virtuelle Festplattendatei)
- bs=1M setzt die Blockgröße auf 1 Megabyte (wie viele Daten auf einmal kopiert werden sollen)
- count=256 bedeutet, 256 Blöcke zu kopieren (was zu einer 256 MB großen Datei führt)
Dies erstellt eine leere Datei voller Nullen, die wir als unsere virtuelle Festplatte verwenden werden.
Überprüfen Sie die Dateigröße:
```
ls -lh virtual.img
```
Sie sollten sehen, dass virtual.img genau 256 MB groß ist.
Formatieren wir nun diese virtuelle Festplatte mit einem ext4-Dateisystem:
```
sudo mkfs.ext4 virtual.img
```
Was passiert hier? Dieser Befehl:
- Erstellt ein neues ext4-Dateisystem innerhalb unserer virtuellen Festplattendatei
- Richtet die grundlegende Struktur ein, die zum Speichern von Dateien und Verzeichnissen erforderlich ist
- Ähnelt dem Formatieren eines neuen USB-Laufwerks vor der ersten Verwendung
Das ext4-Dateisystem ist der Standard für viele Linux-Distributionen, da es zuverlässig und gut getestet ist.
Als Nächstes müssen wir einen Mount-Point erstellen. Dies ist das Verzeichnis, in dem der Inhalt unserer virtuellen Festplatte erscheinen wird:
```
sudo mkdir /mnt/virtualdisk
```
Stellen Sie sich einen Mount-Point als "Fenster" zu Ihrer virtuellen Festplatte vor. Nach dem Mounten sehen Sie, wenn Sie in dieses Verzeichnis schauen, tatsächlich den Inhalt der virtuellen Festplatte.
Jetzt können wir die virtuelle Festplatte mounten:
```
sudo mount -o loop virtual.img /mnt/virtualdisk
```
Lassen Sie uns aufschlüsseln, was hier passiert:
- Die Option -o loop weist Linux an, unsere Datei so zu behandeln, als wäre sie ein echtes Festplattengerät
- virtual.img ist unsere Quelle (die virtuelle Festplatte, die wir erstellt haben)
- /mnt/virtualdisk ist der Ort, an dem der Inhalt erscheinen soll
Dies ähnelt dem, was automatisch passiert, wenn Sie ein USB-Laufwerk anschließen, nur dass wir es manuell mit unserer virtuellen Festplattendatei tun.
Überprüfen wir, ob die Festplatte gemountet ist:
```
mount | grep virtualdisk
```
Sie sollten eine Zeile sehen, die anzeigt, dass virtual.img unter /mnt/virtualdisk gemountet ist.
Jetzt, da sie gemountet ist, können wir sie wie jedes andere Verzeichnis verwenden. Erstellen wir eine Datei:
```
sudo touch /mnt/virtualdisk/testfile
ls /mnt/virtualdisk
```
Sie sollten testfile in der Liste sehen.
Wenn Sie mit der Verwendung der virtuellen Festplatte fertig sind, sollten Sie sie unmounten:
```
sudo umount /mnt/virtualdisk
```
Das Unmounten entfernt das Dateisystem aus diesem Verzeichnis und stellt sicher, dass das Betriebssystem alle ausstehenden Lese- und Schreibvorgänge abschließt, bevor es die Verbindung trennt. Ein unsachgemäßes Unmounten kann zu Datenbeschädigung führen. Obwohl sich die Befehlssyntax auf das Unmounten des Verzeichnisses konzentriert, weiß das Betriebssystem im Hintergrund, dass dieses Verzeichnis dem gemounteten Festplatten-Image entspricht.

Dieser Prozess des Erstellens, Formatierens und Mountens einer virtuellen Festplatte ist sehr ähnlich zu dem, was passiert, wenn Sie eine neue Festplatte oder einen USB-Stick anschließen. Der Hauptunterschied besteht darin, dass wir alles mit einer Datei anstelle eines physischen Geräts tun.

Das Mounten eines Dateisystems bedeutet, es an ein bestimmtes Verzeichnis anzuhängen, damit das Betriebssystem auf die Daten innerhalb des Dateisystems zugreifen kann. In diesem Lab wird die virtuelle Festplatten-Image-Datei so behandelt, als wäre sie eine physische Festplatte, und das Mounten macht ihren Inhalt in einem bestimmten Verzeichnis (z. B. /mnt/virtualdisk) verfügbar.

Festplattenpartitionen mit fdisk verwalten

In einem echten System müssen Sie oft Partitionen erstellen, bevor Sie ein Dateisystem erstellen können. Obwohl wir in dieser virtuellen Umgebung keine tatsächlichen Festplattenpartitionen ändern können, können wir untersuchen, wie man fdisk verwendet, um Partitionsinformationen anzuzeigen.

Lassen Sie uns zunächst Informationen über alle Festplattenpartitionen anzeigen:
```
sudo fdisk -l
```
Dies zeigt Informationen über alle Festplattengeräte und deren Partitionen an. Sie sehen Details zur Festplattengröße, Anzahl der Sektoren und zur Partitionstabelle.
Lassen Sie uns nun die Partitionsinformationen für unsere virtuelle Festplatte ansehen:
```
sudo fdisk -l virtual.img
```
Dies zeigt Ihnen die Partitionstabelle der virtuellen Festplatte. Da wir das Dateisystem direkt auf dem Festplatten-Image ohne Partitionierung erstellt haben, sehen Sie möglicherweise eine Meldung, dass es keine gültige Partitionstabelle enthält.

In einem echten System würden Sie fdisk interaktiv verwenden, um Partitionen zu erstellen, zu löschen oder zu ändern. Hier ist ein kurzer Überblick darüber, wie das funktionieren würde:

Sie starten fdisk mit sudo fdisk /dev/sdX (ersetzen Sie X durch den entsprechenden Buchstaben für die Festplatte, die Sie partitionieren möchten)
Sie verwenden den Befehl 'n', um eine neue Partition zu erstellen
'd' würde eine Partition löschen
't' würde die System-ID einer Partition ändern (die den beabsichtigten Verwendungszweck der Partition angibt)
'w' würde die Änderungen schreiben und beenden

Denken Sie daran, dass das Ändern von Partitionen zu Datenverlust führen kann. Seien Sie also immer vorsichtig und sichern Sie wichtige Daten, bevor Sie Änderungen an Festplattenpartitionen vornehmen.

Fdisk beschränkt sich nicht nur auf die Anzeige von Partitionsinformationen. Es kann auch interaktiv Festplattenpartitionen erstellen, löschen und ändern. Obwohl es ein wesentliches Werkzeug für die Festplattenpartitionierung ist, seien Sie vorsichtig, wenn Sie fdisk verwenden, um Partitionen auf einem System zu ändern, das kritische Daten enthält; unsachgemäße Änderungen können zu Datenverlust führen.

Zusammenfassung

Herzlichen Glückwunsch! In diesem Lab haben Sie gelernt, wie man:

Die Festplattennutzung mit df anzeigt
Verzeichnisgrößen mit du untersucht
Eine virtuelle Festplatte erstellt, formatiert, mountet und unmountet
Partitionsinformationen mit fdisk anzeigt

Diese Fähigkeiten bilden eine Grundlage für fortgeschrittenere Aufgaben der Linux-Systemadministration. Sie sind entscheidend für die Verwaltung von Speicherplatz, die Fehlerbehebung bei Festplattenplatzproblemen und die Aufrechterhaltung der Gesundheit des Dateisystems in Linux-Systemen.

Versuchen Sie als zusätzliche Herausforderung, ein Shell-Skript zu schreiben, das die 10 größten Dateien oder Verzeichnisse in Ihrem Home-Verzeichnis findet und deren Größen in einem menschenlesbaren Format anzeigt. Dies kombiniert mehrere der Befehle, die Sie in diesem Lab gelernt haben.

Denken Sie daran, dass Übung der Schlüssel zur Beherrschung dieser Konzepte ist. Zögern Sie nicht, mit diesen Befehlen (in einer sicheren Umgebung) zu experimentieren, um Ihr Verständnis zu vertiefen. Viel Erfolg auf Ihrer weiteren Lernreise in der Linux-Systemadministration!