Gast.
Level 1 Benutzer
Keine Registrierung erforderlich. Fortschritt wird lokal gespeichert. Exportieren Sie Ihren Spielstand für andere Geräte.
ERRUNGENE ABZEICHEN
HILFE & RECHTLICHES
Online Linux-Terminal-Praxis — Lernen durch Machen.
Meistern Sie wichtige Linux-Befehle durch ein kostenloses Bash-Lernspiel und eine interaktive Dateisystem-Simulation.
Interaktiver Lernpfad & Terminal-Ziele.
Ihr kompletter Linux-Lernpfad mit strukturierten Lernzielen. Klicken Sie auf einen freigeschalteten Knoten, um Ihren Terminal-Arbeitsbereich zu öffnen.
1. Dateisystem-Grundlagen
Wer bin ich und wo bin ich?
Stellen Sie sich vor, Sie betreten eine riesige, dunkle Bibliothek mit Millionen von Büchern, haben aber keine Karte und können sich nicht einmal an Ihr eigenes Namensschild erinnern. Bevor Sie etwas nachschlagen können, müssen Sie wissen, wer Sie sind und wo Sie stehen. In der Linux-Shell beginnen wir mit genau den gleichen Fragen! - Der Befehl `whoami` gibt den Benutzernamen aus, unter dem Sie derzeit angemeldet sind. - Der Befehl `pwd` (Arbeitsverzeichnis drucken) funktioniert wie ein GPS und zeigt Ihnen den genauen Ordnerpfad an, in dem Sie sich gerade befinden.
Navigieren und Auflisten von Dateien
Nachdem Sie nun wissen, wo Sie sich befinden, wie können Sie sich umschauen und in einen anderen Raum in dieser digitalen Bibliothek wechseln? Unter Linux machen wir das mit zwei einfachen Befehlen: - `ls`: Es ist, als würde man das Licht in einem Raum einschalten, um alle darin befindlichen Dateien und Ordner zu sehen. - `cd <path>`: Abkürzung für „Verzeichnis wechseln“, damit können Sie durch eine Tür in einen anderen Ordner gehen. Um anzugeben, wohin Sie gehen möchten, können Sie **absolute** Pfade (beginnend mit dem Stammverzeichnis `/` des Systems, wie `/var/log`) oder **relative** Pfade (basierend darauf, wo Sie sich gerade befinden, wie mit `..`, um zurück in den übergeordneten Ordner zu gelangen) verwenden.
Linux-Verzeichnisstruktur und FHS
Jedes Linux-System folgt einer Standard-Dateisystemhierarchie, beginnend mit dem Stammverzeichnis `/`. Im Gegensatz zu Windows (das Laufwerksbuchstaben wie `C:` oder `D:` verwendet) vereinheitlicht Linux alle Dateien und Speicher unter `/`. Hier sind die wichtigsten Systemverzeichnisse, die jeder Linux-Benutzer kennen sollte: - `/` (Root): Der übergeordnete Ordner der obersten Ebene des gesamten Systems. - `/etc`: Enthält Systemkonfigurationen (z. B. `/etc/hosts`, `/etc/passwd`). - `/var`: Enthält variable Daten, die sich im Laufe der Zeit ändern (Protokolle, Spool, Caches wie `/var/log`). - `/home`: Persönliche Ordner des Benutzers (z. B. `/home/learner`). - `/tmp`: Temporärer Speicherbereich für transiente Dateien. - `/usr`: Benutzerdienstprogramme, Anwendungen und Systembibliotheken.
Erstellen von Verzeichnissen
Stellen Sie sich vor, auf Ihrem Schreibtisch stapeln sich lose Papiere und Sie benötigen physische Ordner, um für Ordnung zu sorgen. Unter Linux organisieren wir Dateien, indem wir mit dem Befehl `mkdir` (Verzeichnis erstellen) Ordner (Verzeichnisse) erstellen. Wenn Sie `mkdir code` ausführen, wird genau dort, wo Sie sich befinden, ein brandneuer Ordner mit dem Namen „code“ erstellt. Sie können Ordner an einer beliebigen Stelle im Dateisystem erstellen, indem Sie `mkdir` einen relativen oder absoluten Pfad zuweisen.
Verschachtelte Verzeichnisse und Optionen
Stellen Sie sich vor, Sie versuchen, eine Reihe von Nistpuppen zu bauen, aber Sie müssen die äußersten Puppen bauen, bevor Sie die winzige Puppe im Inneren bauen können. Standardmäßig ist `mkdir` so: Es weigert sich, einen Ordner tief in Ordnern zu erstellen, die noch nicht vorhanden sind. Um den Aufwand, Ordner einzeln zu erstellen, zu vermeiden, verwenden wir einen Schalter: – Die Option `-p` (oder `--parents`) weist `mkdir` an, auf dem Weg zum endgültigen Ordner automatisch alle fehlenden übergeordneten Ordner zu erstellen. Beispielsweise erstellt `mkdir -p workspace/src/utils` `workspace`, `workspace/src` und `workspace/src/utils` in einem einzigen Befehl. **Warum das wichtig ist**: Wenn Sie `mkdir workspace/src/utils` ohne `-p` ausführen und `workspace` und `workspace/src` noch nicht vorhanden sind, erhalten Sie: `mkdir: cannot create directory 'workspace/src/utils': No such file or directory`. Das Flag `-p` behebt dieses Problem, indem alle fehlenden übergeordneten Ordner automatisch erstellt werden.
Den Bildschirm freimachen
Sind Sie schon einmal überwältigt, wenn Ihr Schreibtisch voller unordentlicher Notizen und Papiere ist? Ihr Terminal kann genauso überfüllt sein. Wenn dies der Fall ist, können Sie den gesamten alten Text entfernen und neu beginnen. – Der Befehl `clear` löscht den sichtbaren Bildschirm und verschiebt die vorherige Ausgabe aus dem Blickfeld, sodass Sie oben im Terminal eine neue, leere Leinwand haben.
Shell-Hilfe finden
Wenn Sie ein neues Brettspiel kaufen, werfen Sie normalerweise einen Blick auf das Regelbuch oder die Referenzkarte, um zu sehen, welche Züge erlaubt sind. In unserem Terminalemulator gibt es einen integrierten Spickzettel! – Der Befehl `help` listet jeden einzelnen Befehl auf, den dieser Simulator unterstützt, zusammen mit Details darüber, ob er die Weiterleitung oder Umleitung von Ausgaben unterstützt.
2. Dateimanipulation
Erstellen leerer Dateien
Stellen Sie sich vor, Sie möchten mit dem Schreiben eines neuen Tagebucheintrags beginnen, benötigen aber zunächst ein leeres Blatt Papier. Unter Linux holen wir uns mit dem Befehl `touch` eine neue, leere Textdatei. – Der Befehl `touch` erstellt eine brandneue, leere Datei, wenn sie noch nicht existiert (wie das Ausführen von `touch draft.txt`, um `draft.txt` zu erstellen). Wenn die Datei bereits vorhanden ist, wird einfach der Zeitstempel „zuletzt geändert“ der Datei aktualisiert, ohne ihren Inhalt zu ändern. Legen wir eine Datei in unserem neuen Projektordner ab.
Dateiinhalte lesen
Stellen Sie sich vor, Sie öffnen einen Ordner, ziehen eine Textseite heraus und halten sie zum Lesen hoch. Unter Linux können wir Dateien mit dem Befehl `cat` (verketten) sofort lesen, ohne einen umfangreichen Texteditor öffnen zu müssen. - Der Befehl `cat` druckt den gesamten Inhalt einer Datei direkt auf Ihrem Terminalbildschirm. Wenn Sie beispielsweise `cat notes.txt` ausführen, können Sie sofort sehen, was in `notes.txt` geschrieben ist.
Einen Blick auf Dateien werfen (Kopf und Ende)
Da Sie nun mit `cat` eine ganze Datei lesen können, stellt sich die Frage, ob die Datei Tausende von Zeilen enthält und Sie nur den oberen oder unteren Rand sehen möchten. Das Dumpen einer riesigen Datei mit `cat` überschwemmt Ihren Bildschirm. Stattdessen verwenden wir `head` und `tail`, um einen Blick auf die Kanten zu werfen. – Der Befehl `head` zeigt standardmäßig die ersten 10 Zeilen einer Datei an. Sie können dies mit `-n <number>` ändern (z. B. `head -n 5 log.txt` für die ersten 5 Zeilen). – Der Befehl `tail` zeigt standardmäßig die letzten 10 Zeilen an und unterstützt dieselbe `-n`-Option. - Entscheidend ist, dass `tail -f` (folgen) eine Datei in Echtzeit überwacht und neue Zeilen anzeigt, während sie vom System geschrieben werden. Dies ist das beliebteste Tool eines Systemadministrators zum Ansehen von Live-Protokollen.
Interaktives Scrollen von Dateien (weniger und mehr)
Der Blick auf den Anfang und das Ende einer Datei mit `head` und `tail` ist großartig, aber was ist, wenn Sie eine lange Konfigurationsdatei Seite für Seite durchsuchen müssen? Dafür gibt es Pager wie `less` und `more`. - Pager laden Dateien interaktiv und zeigen jeweils eine Textseite an, um eine Systemverlangsamung bei großen Dateien zu verhindern. - `less` ist die moderne Wahl, mit der Sie mit den Pfeiltasten vorwärts und rückwärts scrollen, mit `/` nach Text suchen und durch Drücken von `q` beenden können. - `more` ist ein älterer, einfacherer Pager, der nur vorwärts scrollt.
Umgang mit Leerzeichen in Dateinamen
Wenn Sie einem Roboter sagen, er solle „mein Schlafzimmer blau streichen“, muss er wissen, ob „mein Schlafzimmer“ ein einzelner Ort ist oder ob „mein“ und „Schlafzimmer“ zwei verschiedene Anweisungen sind. Linux verwendet Leerzeichen, um Befehle von ihren Argumenten zu trennen. Wenn Sie also `mkdir my folder` ausführen, geht Linux davon aus, dass Sie zwei separate Ordner erstellen möchten: einen mit dem Namen „my“ und einen mit dem Namen „folder“! – Um Linux mitzuteilen, dass ein Name mit Leerzeichen ein einzelnes Element ist, müssen wir ihn in Anführungszeichen setzen (`"my folder"` oder `'my folder'`) oder einen Backslash verwenden, um das Leerzeichen zu maskieren (`my\ folder`).
Dateien schreiben und überschreiben
Wenn Sie eine Nachricht an eine Tafel schreiben möchten, wischen Sie die Tafel zunächst vollständig sauber und schreiben dann Ihre neuen Wörter. Unter Linux schreiben wir Nachrichten mit dem Operator `>` (Ausgabeumleitung) in Dateien. - Der Befehl `echo "message"` gibt normalerweise Text auf dem Bildschirm aus. – Durch das Hinzufügen des `>`-Symbols leiten wir diesen Text stattdessen in eine Datei um. Beispielsweise schreibt `echo "Hi" > greeting.txt` „Hallo“ in `greeting.txt`. Wenn die Datei bereits Text enthält, überschreibt `>` diesen vollständig mit der neuen Nachricht.
An Dateien anhängen
Anstatt die Tafel zu bereinigen, was wäre, wenn Sie unten einfach eine neue Zeile hinzufügen möchten? Unter Linux fügen wir mithilfe des Operators `>>` (Umleitung anhängen) Text am Ende einer Datei hinzu, ohne den vorhandenen Inhalt zu berühren. - Der `>>`-Operator hängt Ihren neuen Text ganz unten an die Datei an. Beispielsweise fügt `echo "New Line" >> logs.txt` „Neue Zeile“ am Ende von `logs.txt` hinzu, während alle Ihre alten Protokolle sicher bleiben.
Kopieren und Verschieben von Dateien
Stellen Sie sich vor, Sie würden Ihren Raum neu organisieren: Manchmal möchten Sie eine Fotokopie eines Dokuments erstellen, um es in einer anderen Schublade aufzubewahren, und ein anderes Mal möchten Sie einfach einen Ordner nehmen und ihn in ein neues Regal schieben oder die Beschriftung ändern. Wir machen das unter Linux mit einfachen Befehlen: - `cp <source> <destination>` erstellt ein identisches Duplikat einer Datei an einem neuen Speicherort. - `mv <source> <destination>` verschiebt eine Datei in einen neuen Ordner oder benennt die Datei um, wenn Sie sie im selben Ordner behalten (z. B. `mv old.txt new.txt`).
Platzhalter und Operationen mit mehreren Dateien
Stellen Sie sich vor, Sie haben einen Stapel Ordner mit den Bezeichnungen „log_monday“, „log_tuesday“ und „log_wednesday“ und möchten alle auf einmal öffnen und lesen, ohne jeden Namen eintippen zu müssen. Unter Linux können Sie **Platzhalter** als Suchverknüpfungen verwenden! - Das Symbol `*` entspricht allen Zeichen beliebiger Länge. Beispielsweise liest `cat log_*` jede Datei, die mit „log_“ beginnt. - Das Symbol `?` fungiert als Platzhalter für ein einzelnes Zeichen. Beispielsweise stimmt `log_?.txt` mit `log_1.txt` überein, ignoriert jedoch `log_12.txt`.
Entfernen von Dateien und Ordnern
Wenn Sie Ihren Schreibtisch aufräumen, werfen Sie möglicherweise alte Papiere in einen Papierkorb, wo Sie sie zurückholen können, wenn Sie einen Fehler gemacht haben. Unter Linux gibt es kein Sicherheitsnetz – wenn Sie etwas vom Terminal löschen, ist es für immer verloren! - Der Befehl `rm` löscht Dateien. – Da Ordner andere Dateien enthalten können, löscht `rm` standardmäßig keinen Ordner. Sie müssen das Flag `-r` (rekursiv) hinzufügen, um Linux anzuweisen, in den Ordner einzutauchen und ihn mit allem darin zu löschen. **Warum das wichtig ist**: Wenn Sie `rm downloads` ohne `-r` ausführen, während `downloads` ein Ordner ist, erhalten Sie: `rm: cannot remove 'downloads': Is a directory`. Das Flag `-r` weist Linux an, den Ordner und alles darin rekursiv zu löschen.
3. Pipes & Filterung
Einführung in Rohre und WC
Stellen Sie sich ein Fließband vor, an dem ein Arbeiter ein Produkt verpackt und es sofort dem nächsten Arbeiter übergibt, der es in einen Karton verpackt – keine Zwischenlagerung erforderlich. Unter Linux verbinden wir Befehle genau so mit einer **Pipe** (`|`). – Eine Pipe (`|`) leitet die Ausgabe eines Befehls direkt an die Eingabe des nächsten Befehls weiter. Beispielsweise listet `ls | wc -l` Dateien auf und übergibt diese Liste sofort an `wc -l` (Wortzählung – Zeilen), der sie im laufenden Betrieb zählt, ohne dass temporäre Dateien erforderlich sind. **Warum das wichtig ist**: Wenn Sie `wc` ohne `-l` ausführen, werden drei separate Zahlen ausgegeben: Zeilen, Wörter und Bytes (z. B. ` 5 10 85`). Dies erschwert die Verwendung in Pipelines oder Skripten, die eine saubere Einzelzahlzählung erfordern. Das Flag `-l` begrenzt die Ausgabe auf die Zeilenanzahl.
Unikate sortieren und finden
Stellen Sie sich vor, Sie sortieren ein Kartenspiel, in dem überall Duplikate verstreut sind. Um Duplikate leicht zu erkennen und zu entfernen, gruppieren Sie zunächst die identischen Karten. Unter Linux filtert der Befehl `uniq` sich wiederholende Zeilen heraus, hat aber einen Haken: Er erkennt **nur Duplikate, die direkt nebeneinander liegen**! – Um alle Duplikate aus einer unübersichtlichen Liste zu entfernen, müssen Sie die Zeilen zunächst mit `sort` sortieren und dann das Ergebnis an `uniq` übergeben. Beispielsweise organisiert und bereinigt `sort raw.txt | uniq` die Liste auf einmal.
Filtern mit grep
Stellen Sie sich vor, Sie durchsuchen ein riesiges, tausendseitiges Logbuch, um jedes Mal zu finden, wann ein Systemfehler aufgetreten ist. Dies manuell zu erledigen, würde Stunden dauern! Unter Linux verwenden wir `grep` als unsere digitale Lupe, um sofort nach bestimmten Wörtern oder Mustern zu suchen. – Der Befehl `grep` filtert Dateien oder weitergeleiteten Text und druckt nur die Zeilen, die Ihrem Suchwort entsprechen. Wenn Sie beispielsweise `grep "ERROR" logs.txt` ausführen, wird die Datei gescannt und nur die Zeilen extrahiert, die „ERROR“ enthalten.
4. Umleitung & Sicherheit
Ändern von Dateiberechtigungen
Stellen Sie sich vor, Sie führen ein Unternehmen, in dem nur Manager Schecks unterzeichnen können, Mitarbeiter Zeitpläne lesen können und Besucher nur auf das Ladenschild schauen können. Unter Linux steuern wir mithilfe eines Sicherheitssystems aus Zahlen (sogenannte Oktaldarstellung), wer Dateien lesen, schreiben oder ausführen kann: - `7` = Vollzugriff: Lesen + Schreiben + Ausführen (`rwx`) - `6` = Zugriff ändern: Lesen + Schreiben (`rw-`) - `5` = Lese- und Ausführungszugriff: Lesen + Ausführen (`r-x`) - `4` = Nur-Lese-Zugriff: Lesen (`r--`) Wir wenden diese Einstellungen mit `chmod <octal> <file>` an. Mit `chmod 755 script.sh` können Sie beispielsweise das Skript ausführen, während andere es nur lesen und ausführen können. Wir haben ein Skript namens `deploy.sh`, das derzeit gesperrt ist – machen wir es ausführbar!
Versteckte Dateien und Konfigurationen
Stellen Sie sich eine geheime Schublade unter Ihrem Schreibtisch vor, in der Sie Systemeinstellungen aufbewahren, damit diese Ihren Hauptarbeitsplatz nicht überladen. Unter Linux erstellen wir versteckte Dateien, indem wir ihre Namen einfach mit einem Punkt (`.`) beginnen. – Diese Dotfiles (wie `.bashrc` oder `.config`) speichern Benutzereinstellungen und Konfigurationseinstellungen im Hintergrund. – Ein Standardbefehl `ls` zeigt sie nicht an. Um einen Blick auf diese versteckten Dateien zu werfen, müssen Sie das Flag `-a` (alle) hinzufügen und `ls -a` ausführen. **Warum das wichtig ist**: Wenn Sie `ls` ohne `-a` ausführen, werden versteckte Dateien (deren Namen mit `.` beginnen) vollständig aus der Ausgabe weggelassen. Sie werden wichtige Dateien wie `.config_names` nicht sehen und denken möglicherweise, dass sie fehlen. Das Flag `-a` weist `ls` an, alle Dateien aufzulisten, einschließlich der versteckten.
Ändern des Dateieigentums
Stellen Sie sich vor, Sie kaufen ein Haus und müssen die Urkunde offiziell unter dem Namen eines neuen Eigentümers registrieren. Unter Linux hat jede Datei und jeder Ordner einen offiziellen Besitzer und eine Gruppe. Wenn Sie den Besitz einer Datei an eine andere Person (z. B. den Systemadministrator) übergeben müssen, verwenden Sie den Befehl `chown` (Eigentümer ändern). - Da es sich bei der Änderung des Eigentümers einer Datei um eine sensible Sicherheitsmaßnahme handelt, müssen Sie ihr `sudo` voranstellen, um sie mit Administratorrechten auszuführen. Beispielsweise weist `sudo chown root reports.csv` die Datei dem Benutzer „root“ zu.
Linux-Firewalls (ufw & iptables)
Stellen Sie sich vor, Sie leben in einem sicheren Wohnhaus, in dem ein Wachmann am Eingang steht, der Ausweise überprüft und unbefugte Besucher blockiert. Unter Linux fungiert eine **Firewall** als Sicherheitswächter für Ihre Netzwerkports. - Der Befehl `ufw` (Uncomplicated Firewall) ist eine benutzerfreundliche Oberfläche zum Verwalten von Firewall-Regeln. Durch Ausführen von `sudo ufw status` wird angezeigt, ob die Firewall aktiv ist und welche Ports (z. B. Port 22 für SSH oder Port 80 für Webserver) geöffnet sind. – Der Befehl `iptables` ist das traditionelle Netfilter-Tool auf niedriger Ebene, das tatsächlich Pakete blockiert oder umleitet. Beim Ausführen von `sudo iptables -L` werden die aktiven Sicherheitsketten und Paketabgleichsregeln aufgelistet.
5. Superuser & Paketverwaltung
Superuser-Berechtigungen (sudo)
Stellen Sie sich vor, Sie arbeiten an Ihrem Computer mit einem Standardkonto, um zu verhindern, dass versehentlich wichtige Betriebssystemdateien gelöscht werden. Wenn Sie Software installieren oder Systemeinstellungen ändern müssen, fordert Ihr Computer eine Administratorautorisierung an. Unter Linux verwenden wir `sudo` (kurz für „Superuser Do“) als unsere Verwaltungsschlüsselkarte. - Der Benutzer `root` ist das Hauptadministratorkonto mit vollständiger Kontrolle über das System. - Standardbenutzern ist das Lesen sensibler Dateien (wie der Passwortdatenbank `/etc/shadow`) untersagt. Durch die Eingabe von `sudo` vor einem Befehl führen Sie ihn mit temporären Administratorrechten aus, um diese Blöcke zu umgehen.
Paketverwaltung (apt)
Denken Sie an die Installation von Apps auf Ihrem Smartphone über den App Store oder Google Play Store. Es ist sicher, kuratiert und automatisiert. Unter Linux verwenden wir einen Befehlszeilen-App-Store namens Paketmanager, um Software sicher abzurufen und zu installieren. - Auf Ubuntu/Debian-Systemen ist der Standardpaketmanager `apt` (Advanced Packaging Tool). - Durch die Installation von Software werden systemweite Ordner geändert, daher müssen Sie sie immer mit `sudo` autorisieren. Beispielsweise lädt `sudo apt install tree` den Verzeichnisvisualisierer „tree“ herunter und installiert ihn.
Durchsuchen von Paketen (apt search)
Wie finden Sie vor der Installation von Software unter Linux heraus, welche Pakete im Repository verfügbar sind? Unter Linux verwenden wir `apt search`, um den Softwarekatalog nach Schlüsselwörtern abzufragen. – Der Befehl `apt search <keyword>` durchsucht die Repository-Beschreibungen und listet passende Softwarepakete zusammen mit ihren Versionen auf. – Im Gegensatz zu `apt install` werden beim Durchsuchen von Paketrepositorys nur lokale Katalogindexdateien gelesen und **keine** Superuser-Berechtigungen (`sudo`) erforderlich.
Pakete bereinigen (apt purge)
Bei der Deinstallation von Software unter Linux deinstalliert der Standard-`apt remove` die Binärdateien der Anwendungen, hinterlässt aber die Systemkonfigurationsdateien für den Fall einer späteren Neuinstallation. Um ein Softwarepaket vollständig zu entfernen UND alle zugehörigen Konfigurationsdateien zu löschen, verwenden wir `apt purge` (oder `apt remove --purge`). – Der Befehl `sudo apt purge <package>` entfernt die Anwendung und löscht alle verbleibenden Konfigurationsdateien. – Da beim Löschen systemweite Ordner und Konfigurationsdateien geändert werden, sind Superuser-Berechtigungen (`sudo`) erforderlich.
Debian-Paketverwaltung (dpkg)
Während `apt` das Herunterladen und Auflösen von Paketabhängigkeiten aus Repositorys automatisiert, was ist, wenn Sie eine `.deb`-Paketdatei bereits manuell heruntergeladen haben und diese überprüfen oder installieren möchten? Unter Linux verwenden wir `dpkg` (Debian-Paket), um direkt mit Paketen zu interagieren. – Der Befehl `dpkg -l` listet alle Pakete auf, die derzeit auf Ihrem Debian/Ubuntu-System installiert sind. – Der Befehl `dpkg -s <package>` zeigt Status-, Versions- und Architekturinformationen für ein bestimmtes Paket an.
RedHat-Paketmanager (yum & dnf)
Nicht alle Linux-Umgebungen basieren auf Debian/Ubuntu. Wenn Sie auf RedHat-, Fedora- oder CentOS-Systemen arbeiten, werden Sie `apt` oder `dpkg` nicht finden. Stattdessen verwalten Sie Pakete mit älteren `yum`- oder modernen `dnf`-Paketmanagern (Dandified YUM). – Der Befehl `dnf check-update` (oder `yum check-update`) stellt eine Verbindung zu RedHat-Repositorys her, um nach verfügbaren Paketaktualisierungen zu suchen. - Der Befehl `dnf install <package>` ruft und installiert Programme ähnlich wie `apt install`.
6. Festplatte & Systemressourcen
Überprüfen des Speicherplatzes (df)
Stellen Sie sich vor, Sie versuchen, ein riesiges Videospiel herunterzuladen und erhalten die Fehlermeldung „Speicher voll“, aber Sie sind sich nicht sicher, welches Laufwerk der Engpass ist. Unter Linux überprüfen wir die Speicherkapazität unseres Systems mit dem Befehl `df` (disk free). – Der Befehl `df` zeigt den gesamten, belegten und verfügbaren Speicherplatz auf allen angeschlossenen Laufwerken an. - Durch Ausführen von `df -h` (Hinzufügen des `-h`-Flags für „für Menschen lesbar“) sehen Sie den Speicher in benutzerfreundlichen Gigabyte (G) und Megabyte (M) statt verwirrender Blockzahlen, sodass Sie leicht erkennen können, welches Laufwerk (wie `/` oder `/home`) voll ist. **Warum das wichtig ist**: Wenn Sie `df` ohne `-h` ausführen, werden die Größen in rohen 1K-Blockzahlen angezeigt (z. B. `49258284` anstelle von `47G`), was für einen Menschen äußerst schwer zu lesen und zu berechnen ist. Das Flag `-h` formatiert diese Größen in benutzerfreundliche Gigabyte (G) und Megabyte (M).
Verzeichnisgrößen ermitteln (du)
Wenn Sie wissen, *welches* Laufwerk voll ist, wie finden Sie dann den spezifischen Ordner, der Ihren gesamten Speicherplatz hortet? Ist es Ihr Download-Ordner oder vielleicht ein versteckter Cache? Wir lösen dieses Rätsel mit dem Befehl `du` (Festplattennutzung). - `du <directory>` listet die Größe eines Ordners und aller darin enthaltenen Unterordner auf. - `du -sh <directory>` (wobei `-s` „Zusammenfassung“ und `-h` „für Menschen lesbar“ bedeutet) berechnet und druckt eine einzelne, saubere Gesamtgröße für diesen bestimmten Ordner. **Warum das wichtig ist**: Wenn Sie `du` ohne `-s` ausführen, wird eine riesige Textwand ausgegeben, die jedes einzelne Unterverzeichnis und jede einzelne Datei rekursiv auflistet, anstatt eine einzige Zusammenfassung zu geben. Das Flag `-s` fasst die Gesamtgröße des Ordners zusammen und `-h` macht ihn für Menschen lesbar.
Überprüfen der Speichernutzung (kostenlos)
Stellen Sie sich vor, Ihr Laptop fängt an zu stagnieren, Webseiten frieren ein und der Wechsel zwischen Apps fühlt sich quälend langsam an. Dies bedeutet normalerweise, dass Ihr Computer nicht mehr über genügend aktiven Speicher (RAM) verfügt. Unter Linux können wir mit dem Befehl `free` überprüfen, wie viel Spielraum unser System hat. – Der Befehl `free` zeigt den gesamten, verwendeten und verfügbaren physischen Speicher (RAM) und Auslagerungsspeicher an. – Durch das Hinzufügen des Flags `-h` (unter Ausführung von `free -h`) werden die Speichergrößen in leicht lesbare Gigabyte (GB) und Megabyte (MB) formatiert, sodass Sie erkennen können, ob ein Programm alle Ihre Ressourcen verbraucht. **Warum das wichtig ist**: Wenn Sie `free` ohne `-h` ausführen, wird die Speichernutzung in rohen Kilobytes ausgegeben (z. B. `16323456` statt `16G`), was schnell schwer zu interpretieren ist. Das Flag `-h` skaliert die Zahlen automatisch auf Gigabyte (G) oder Megabyte (M), um das Lesen zu erleichtern.
Systemverfügbarkeit und Kernel-Details
Stellen Sie sich vor, Sie müssten Fehler bei einem Server beheben, der sich nicht mehr richtig verhält, und möchten wissen, ob er kürzlich neu gestartet wurde, oder genau überprüfen, welche Betriebssystemversion unter der Haube läuft. Wir können diese Systemdetails in Sekundenschnelle abfragen: - Der Befehl `uptime` sagt Ihnen genau, wie lange Ihre Maschine seit dem letzten Start in Betrieb war und wie ausgelastet sie war (Systemauslastung). – Der Befehl `uname -a` (Unix-Name) druckt einen vollständigen Bericht über den Kernel, den Plattformnamen und die Maschinenarchitektur Ihres Systems. **Warum das wichtig ist**: Wenn Sie `uname` ohne `-a` ausführen, wird nur der grundlegende Betriebssystemname ausgegeben (z. B. `Linux`). Wichtige Details wie die Kernel-Version, der Plattformname und die Prozessorarchitektur werden weggelassen. Das Flag `-a` druckt alle verfügbaren Systemdetails in einem einzigen Bericht.
Anzeigen von CPU-Details (lscpu)
Bei der Fehlerbehebung bei der Systemleistung oder der Bereitstellung stark beanspruchter Anwendungen müssen Sie die Fähigkeiten der CPU Ihres Systems kennen. Unter Linux lesen wir detaillierte Informationen zur CPU-Architektur mit dem Befehl `lscpu`. – Der Befehl `lscpu` zeigt Prozessordetails wie CPU-Modell, Hersteller, Taktrate, Anzahl der Kerne, Hyper-Threading-Details und Cache-Größen direkt aus dem Kernel-Dateisystem an.
E/A- und CPU-Statistiken (iostat)
Wenn eine Datenbank oder Webanwendung langsam läuft, wie können Sie feststellen, ob das Problem ein CPU-Engpass oder eine langsame Festplatte ist? Unter Linux überwachen wir Systemausgabe-/Eingabeleistungsmetriken mithilfe von `iostat`. – Der Befehl `iostat` zeigt Berichtsstatistiken zur CPU-Auslastung und zum Lese-/Schreibdurchsatz des aktiven Geräts an und hilft Ihnen, Festplattenüberlastungen zu erkennen.
7. Prozessverwaltung
Auflisten laufender Prozesse (ps)
Stellen Sie sich Ihr Betriebssystem wie ein geschäftiges Büro vor, in dem jedem Mitarbeiter (oder jedem ausgeführten Programm) ein eindeutiges Namensschild namens Prozess-ID (PID) zugewiesen wird. Unter Linux nennen wir diese aktiven Programme **Prozesse** und listen sie mit dem Befehl `ps` auf. - Wenn Sie `ps` alleine ausführen, werden nur Programme angezeigt, die in Ihrem aktuellen Terminalfenster ausgeführt werden. - Das Ausführen von `ps aux` verhält sich wie eine Master-Office-Registrierung, die jedes einzelne aktive Programm, das im gesamten System ausgeführt wird, auflistet, wer es gestartet hat und wie viel CPU und Speicher es verbraucht. **Warum das wichtig ist**: Wenn Sie `ps` ohne `aux` ausführen, sehen Sie nur Prozesse, die in Ihrem aktuellen Terminalfenster ausgeführt werden (normalerweise nur `bash` und `ps` selbst). Hintergrunddienste, Systemprozesse oder von anderen Benutzern ausgeführte Programme werden Ihnen nicht angezeigt. Die `aux`-Optionen zeigen alle laufenden Prozesse systemweit an.
Interaktiver Prozessmonitor (oben)
Stellen Sie sich vor, Sie betrachten ein statisches Foto einer Autobahn und nicht den Live-Feed einer Verkehrskamera. Während `ps` Ihnen einen schnellen Überblick darüber gibt, was gerade läuft, können Sie mit `top` die Leistung Ihres Systems live verfolgen. – Der Befehl `top` startet ein interaktives Echtzeit-Dashboard, das alle paar Sekunden aktualisiert wird. Es zeigt die CPU-Auslastung und die durchschnittliche Auslastung an und ordnet dynamisch die ressourcenintensivsten Prozesse, die genau zu diesem Zeitpunkt ausgeführt werden.
Offene Dateien auflisten (lsof)
In Unix-ähnlichen Systemen ist „alles eine Datei“. Das bedeutet, dass nicht nur Textdateien und Ordner, sondern auch Netzwerk-Sockets, Systemhardware und Prozesse als Dateien behandelt werden. Um herauszufinden, auf welche Dateien von welchen laufenden Programmen zugegriffen wird, verwenden wir `lsof` (List Open Files). - Beim Ausführen von `lsof` wird eine umfassende Liste aller geöffneten Dateien angezeigt, zusammen mit der Prozess-ID (PID) und dem Befehl, mit dem sie geöffnet wurden. - Wenn Sie beispielsweise `lsof -i` ausführen, werden alle Netzwerkdateien/Sockets aufgelistet. Dies ist äußerst nützlich, um herauszufinden, welcher Prozess einen bestimmten Netzwerkport (z. B. Port 80) überwacht.
Stoppen unerwünschter Prozesse (Kill)
Stellen Sie sich vor, eine App auf Ihrem Telefon friert ein, sperrt Ihren Bildschirm vollständig und Sie müssen das Schließen erzwingen, damit alles wieder reibungslos läuft. Unter Linux stoppen wir Fehlverhalten oder eingefrorene Programme, indem wir den Befehl `kill` gefolgt von der Prozess-ID (PID) des Programms verwenden. - Beim Ausführen von `kill 1234` wird eine höfliche Anfrage gesendet, in der das Programm aufgefordert wird, seine Arbeit zu speichern und zu schließen. – Wenn es eingefroren ist und die höfliche Anfrage ignoriert, zwingt `kill -9 1234` das Betriebssystem, es sofort herunterzufahren. Wir haben gerade einen außer Kontrolle geratenen Prozess mit PID `9999`, der unsere gesamte CPU beansprucht – schalten wir ihn ab!
Ausführen von Jobs im Hintergrund
Stellen Sie sich vor, Sie versuchen, einen riesigen Ordner auf ein USB-Laufwerk zu kopieren, möchten aber während des Kopierens weiterarbeiten und andere Befehle im selben Fenster eingeben. Unter Linux können wir zeitaufwändige Aufgaben im „Hintergrund“ ausführen, damit sie unsere Befehlszeile nicht blockieren. – Durch das Hinzufügen eines kaufmännischen Und-Zeichens `&` am Ende eines Befehls (z. B. `sleep 100 &`) wird das Terminal angewiesen, ihn im Hintergrund auszuführen und Ihnen sofort Ihre Eingabeaufforderung zu geben. - Der Befehl `jobs` zeigt an, was gerade im Hintergrund läuft. – Der Befehl `fg` (Vordergrund) zieht eine Hintergrundaufgabe zurück in den Mittelpunkt.
Prozessfreundlichkeit (nice & renice)
In einem geschäftigen Büro können einige Aufgaben mit niedriger Priorität (wie das Ablegen von Belegen) warten, während Anfragen mit hoher Priorität sofort bearbeitet werden müssen. Linux verwaltet die Prozesspriorität mithilfe von **Niceness**-Werten zwischen -20 (höchste Priorität) und 19 (niedrigste Priorität). – Der Befehl `nice` startet einen Prozess mit einer benutzerdefinierten Priorität. Z.B. `nice -n 10 sleep 5` startet einen Sleep-Befehl mit einer höflichen Priorität von 10. – Der Befehl `renice` ändert die Planungspriorität eines bereits laufenden Prozesses. Beispielsweise verringert `sudo renice +5 9999` die Priorität des Prozesses 9999.
Hintergrundjobs fortsetzen (bg)
Wir haben bereits gesehen, wie man eine Aufgabe im Hintergrund mit `&` startet und mit `fg` wieder zurückholt. Aber was wäre, wenn Sie einen Befehl ohne `&` gestartet oder mit `Ctrl+Z` angehalten hätten? Sie können es mit `bg` im Hintergrund fortsetzen! – Der Befehl `bg` setzt angehaltene Jobs fort, sodass sie im Hintergrund ausgeführt werden können, ohne dass Ihre Terminal-Eingabeaufforderung blockiert wird.
8. Netzwerk-Fehlerbehebung
Testen der Konnektivität (Ping)
Stellen Sie sich vor, Sie versuchen, eine Webseite zu laden, aber Ihr Browser dreht sich endlos und Sie fragen sich, ob die WLAN-Verbindung zu Hause unterbrochen ist oder ob die Website selbst abgestürzt ist. Unter Linux testen wir unsere grundlegende Netzwerkverbindung mit dem Befehl `ping`. – Der Befehl `ping` sendet winzige Datenpakete an einen Server (wie `google.com`) und misst, wie viele Millisekunden es dauert, eine Antwort zu erhalten. – Unter Linux läuft `ping` standardmäßig für immer weiter. Damit es nach ein paar Versuchen stoppt, verwenden wir das Flag `-c` (count) und führen `ping -c 3 google.com` aus. **Warum das wichtig ist**: Wenn Sie `ping google.com` ohne `-c` ausführen, werden unbegrenzt weiterhin Pakete gesendet und die Ausgabe gedruckt. Sie müssen es manuell mit `Ctrl+C` unterbrechen, um andere Befehle auszuführen. Das Flag `-c 3` stoppt den Befehl automatisch, nachdem genau 3 Pakete gesendet wurden.
Netzwerkschnittstellen und lokale IP
Stellen Sie sich vor, Sie richten einen Netzwerkdrucker ein oder teilen Dateien mit dem Computer eines Freundes über dasselbe WLAN und müssen die lokale IP-Adresse Ihres Geräts kennen. Unter Linux überprüfen wir unsere Netzwerkhardware und IPs mit dem Befehl `ip`. - Wenn Sie `ip addr` (oder einfach `ip a`) ausführen, wird eine Liste aller Ihrer Netzwerkschnittstellengeräte (wie `eth0` für kabelgebundenes Ethernet oder `wlan0` für WLAN) zusammen mit den ihnen zugewiesenen lokalen IP-Adressen gedruckt.
Überprüfen von Schnittstellen (ifconfig)
Bevor die moderne Befehlssuite `ip` zum Standard wurde, verließen sich Linux-Systemadministratoren auf `ifconfig` (Schnittstellenkonfigurator), um Netzwerkschnittstellen anzuzeigen und zu verwalten. – Der Befehl `ifconfig` zeigt aktive Netzwerkschnittstellen, lokale IP-Konfiguration, Netzmaskendetails und MAC-Hardwareadressen an. Obwohl es auf einigen neueren Distributionen veraltet ist, wird es auf älteren Servern weiterhin häufig verwendet.
Netzwerkverbindungen (nmcli)
Auf modernen Linux-Workstations und -Servern werden Netzwerkschnittstellen von einem System-Daemon namens NetworkManager verwaltet. Anstatt Konfigurationsdateien manuell zu bearbeiten, konfigurieren wir Netzwerkdetails mithilfe von `nmcli`. – Mit dem Befehl `nmcli` (NetworkManager CLI) können Sie Hardwareverbindungen, Gerätezustände und aktive Wi-Fi-Netzwerke überprüfen.
Socket- und Verbindungsstatistiken (netstat & ss)
Beim Einrichten einer Datenbank oder eines Webservers müssen Sie sicherstellen, dass der Dienst ausgeführt wird und den richtigen Port überwacht, und prüfen, ob nicht autorisierte Verbindungen hergestellt werden. Wir tun dies mit `netstat` oder `ss`. - Der Befehl `netstat` (Netzwerkstatistik) ist ein klassisches Tool zum Anzeigen von TCP-Verbindungen und zum Abhören von Ports. Z.B. `netstat -tuln` listet TCP/UDP-Abhörports auf. – Der Befehl `ss` (Socket-Statistik) ist die moderne, schnellere Alternative zu `netstat`, der Socket-Verbindungsdetails direkt aus dem Kernel-Namespace anzeigt.
Verfolgen von Paketrouten (Traceroute)
Wenn eine Webseite nicht geladen werden kann, wie können Sie feststellen, ob das Problem bei Ihrem Heimrouter, Ihrem Internetdienstanbieter (ISP) oder dem Zielserver liegt? Unter Linux verfolgen wir Pakete mit `traceroute`. – Der Befehl `traceroute` listet jedes Router-Gateway (Hop) auf, das ein Paket auf seinem Weg zu einem Remote-Server durchquert, zusammen mit der Antwortlatenz für jeden Hop.
Herunterladen von Webdateien (curl)
Stellen Sie sich vor, Sie möchten eine Datei herunterladen oder den Code eines Setup-Skripts direkt von einem Webserver abrufen, ohne einen Browser zu öffnen und auf die Schaltfläche „Herunterladen“ zu klicken. Unter Linux rufen wir Webdaten mit `curl` (kurz für „Client URL“) ab. - Wenn Sie `curl <url>` ausführen, wird der Seiteninhalt heruntergeladen und direkt auf Ihrem Bildschirm gedruckt. – Um den heruntergeladenen Inhalt als Datei zu speichern, anstatt ihn anzuzeigen, koppeln wir ihn mit der `>`-Umleitung oder dem `-o`-Ausgabeflag.
9. Dateisuche & Finden
Dateien nach Namen suchen (find)
Stellen Sie sich vor, Sie hätten eine wichtige Textdatei irgendwo in Ihrem Benutzerordner verlegt und müssten Dutzende verschachtelter Verzeichnisse nacheinander durchsuchen. Unter Linux umgehen wir das manuelle Suchen, indem wir das Dienstprogramm `find` als blitzschnelle systemweite Suchmaschine verwenden. – Der Befehl `find` durchsucht Verzeichnisbäume nach Name, Größe, Typ oder Datum. - Die Syntax ist `find <where> -name "<pattern>"`. Beispielsweise durchsucht `find . -name "*.txt"` das aktuelle Verzeichnis und alle Unterordner nach Dateien mit der Endung `.txt`. **Warum das wichtig ist**: Wenn Sie `find . "*.log"` ohne `-name` ausführen, erhalten Sie die Fehlermeldung: `find: paths must precede expression: '*.log'`. Das Flag `-name` ist erforderlich, um anzugeben, dass das nachfolgende Muster mit den Dateinamen abgeglichen werden soll.
Überprüfen des Befehlsverlaufs
Stellen Sie sich vor, Sie haben vor zehn Minuten einen langen, komplexen Netzwerkdiagnosebefehl eingegeben und müssen ihn jetzt erneut ausführen, können sich aber nicht an die genauen Optionen oder Syntax erinnern. Anstatt sich den Kopf zu zerkratzen oder alles noch einmal abzutippen, merkt sich Linux alles für Sie! - Der Befehl `history` zeigt eine nummerierte Liste aller Befehle an, die Sie kürzlich ausgeführt haben. - Sie können jedes Element schnell erneut ausführen, indem Sie ein Ausrufezeichen gefolgt von seiner Listennummer eingeben (z. B. `!42`, um Befehl Nr. 42 erneut auszuführen).
Konsultieren von Handbuchseiten
Stellen Sie sich vor, Sie versuchen, einen neuen Befehl zu verwenden, sind sich aber nicht sicher, welche Flags er unterstützt oder wie seine Eingaben formatiert werden sollen. Anstatt online zu suchen, verfügt Linux über ein offizielles, umfassendes Benutzerhandbuch, das direkt in das Terminal integriert ist! - Der Befehl `man` (manuell) gefolgt von einem beliebigen Dienstprogrammnamen (z. B. `man ls`) öffnet ein detailliertes Referenzhandbuch. - Innerhalb der Anleitung scrollen Sie mit den Pfeiltasten, suchen mit „/“ und drücken `q`, um das Handbuch zu schließen und zu Ihrer Eingabeaufforderung zurückzukehren.
10. Dienste & Systemd
Steuern von Diensten (systemctl)
Stellen Sie sich vor, Sie hosten eine Website auf Ihrem Computer, aber Besucher erhalten die Fehlermeldung „Website kann nicht erreicht werden“, weil das Hintergrundprogramm des Webservers nicht ausgeführt wird. Unter Linux werden Hintergrundprozesse, die automatisch starten und im Hintergrund laufen (wie Datenbanken, Firewalls oder Webserver), **Dienste** genannt und wir verwalten sie mit `systemctl`. – Der Befehl `systemctl status <service>` prüft, ob ein Dienst aktiv oder gestoppt ist. - Da das Starten oder Stoppen eines Dienstes Auswirkungen auf alle Benutzer und die Sicherheit des Systems hat, müssen Sie `sudo` verwenden, um Befehle wie `sudo systemctl start <service>` oder `sudo systemctl stop <service>` auszuführen.
Systemprotokollierung (journalctl)
Da Sie nun Hintergrunddienste mit `systemctl` starten und stoppen können, wie beheben Sie Fehler, wenn sie ausfallen? Mit dem Dienstprogramm `journalctl` können Sie Systemprotokolle überprüfen, die von von systemd verwalteten Diensten generiert werden. – Standardmäßig zeigt `journalctl` alle Systemprotokolle an. Da dies massiv sein kann, filtern wir sie, um konzentriert zu bleiben. – Die Option `-u <service>` filtert Protokolle, um nur Nachrichten von einem bestimmten Dienst anzuzeigen (z. B. `journalctl -u apache2`). - Die Option `-n <number>` zeigt nur die neuesten Einträge an (z. B. `journalctl -n 5` für die letzten 5 Protokolle). – Das Flag `-f` (follow) zeigt Protokolle in Echtzeit an, während sie geschrieben werden.
11. Terminal-Textbearbeitung
Bearbeiten von Konfigurationsdateien (nano)
Stellen Sie sich eine SSH-Verbindung zu einem Remote-Cloud-Server vor, auf dem Sie keinen grafischen Desktop oder Cursor haben und schnell eine Zeile in einer Konfigurationsdatei korrigieren müssen. In diesen Szenarien müssen Sie einen Terminal-Texteditor wie `nano` verwenden. - Beim Ausführen von `nano <filename>` wird ein einfacher, leichter Texteditor direkt in Ihr Shell-Fenster geladen. - Die Verknüpfungen werden immer unten auf dem Bildschirm angezeigt: Drücken Sie `Ctrl+O`, um Ihre Änderungen zu schreiben (zu speichern), und `Ctrl+X`, um den Editor zu verlassen.
12. Shell-Skripting & Automatisierung
Schreiben Ihres ersten Bash-Skripts
Stellen Sie sich vor, Sie hätten eine Liste mit 20 Aufgaben, die Sie jeden Morgen ausführen müssen. Das manuelle Eintippen ist mühsam und lässt Platz für Tippfehler. Unter Linux bündeln wir Befehle in einer Datei namens Shell-Skript, damit wir sie alle auf einmal ausführen können! – Jedes Skript beginnt mit einem „shebang“ (`#!/bin/bash`) in der allerersten Zeile, um dem System mitzuteilen, welchen Shell-Interpreter es zum Ausführen der Datei verwenden soll. - Nachdem Sie Ihr Skript gespeichert haben, machen Sie es ausführbar, indem Sie ihm über `chmod 755 script.sh` die Ausführungsberechtigung erteilen und es dann mit `./script.sh` ausführen.
Variablen und Argumente ($1)
Stellen Sie sich vor, Sie erstellen eine personalisierte Willkommensnachricht für eine Website. Sie möchten nicht für jeden einzelnen Kundennamen ein eigenes Skript schreiben! Stattdessen schreiben Sie ein Skript, das beim Ausführen einen Namen als Eingabe verwendet. – In Bash-Skripten enthalten Variablen wie `$1`, `$2` usw. die „Argumente“ oder Eingaben, die Sie an der Befehlszeile übergeben. - Das Ausführen von `./greet.sh Alice` bedeutet beispielsweise, dass `$1` im Skript automatisch den Text „Alice“ enthält. Ebenso verfolgt `$#`, wie viele Eingaben der Benutzer gemacht hat.
Bedingte Logik (if/else)
Stellen Sie sich vor, Sie erstellen ein Skript, das einen CSV-Bericht verarbeitet, aber es stürzt ab, wenn die Berichtsdatei nicht tatsächlich auf der Festplatte vorhanden ist. Um Fehler zu vermeiden, schreiben wir Skripte, die Entscheidungen mithilfe der bedingten Logik `if/else` treffen. - Wir überprüfen Bedingungen mit Klammern: `if [ -f "$1" ]; then ... fi`. - Das Flag `-f` prüft, ob ein Pfad auf eine Datei verweist, während `-d` prüft, ob es sich um ein Verzeichnis handelt. Das Skript verzweigt seine Aktionen abhängig davon, ob die Bedingung wahr oder falsch ist.
Automatisieren mit Schleifen
Stellen Sie sich vor, Sie hätten einen Ordner mit 100 Protokolldateien und müssten von jeder einzelnen eine Sicherungskopie erstellen. Sie einzeln zu kopieren wäre anstrengend. Unter Linux verwenden wir `for`-Schleifen, um dieselbe Aktion automatisch für eine ganze Liste von Elementen zu wiederholen! - Eine `for`-Schleife (wie `for file in *.txt; do ... done`) durchläuft alle Elemente, die einem Muster entsprechen, und verarbeitet sie in Sekundenbruchteilen nacheinander.
Wiederverwendbare Logik (Bash-Funktionen)
Sie haben Schleifen und Bedingungen geschrieben, um Aktionen in Skripten zu automatisieren. Wenn Ihre Skripte jedoch wachsen, wird es schwierig, sie immer wieder zu verwalten, wenn Sie immer wieder dieselbe Logik kopieren. In Bash können wir Befehle in wiederverwendbare Funktionen gruppieren. - Um eine Funktion zu definieren, deklarieren wir sie mit ihrem Namen, gefolgt von Klammern und geschweiften Klammern: `log_msg() { echo "msg"; }`. – Funktionen können wie Shell-Skripte Argumente empfangen, auf die über lokale Positionsparameter `$1`, `$2` usw. im Funktionskörper zugegriffen wird. - Um eine Funktion aufzurufen, verwenden Sie einfach ihren Namen wie jeden anderen Befehl: `log_msg "Backup started"`.
Aufgaben planen (crontab)
Nachdem Sie nun robuste Shell-Skripte geschrieben haben, möchten Sie sich nicht mehr um Mitternacht anmelden, nur um Ihren Backup-Helfer auszuführen. Linux bietet den Dienst `cron`, um Befehle oder Skripte zu bestimmten Zeiten automatisch auszuführen. – Der Cron-Dienst überprüft eine Planungstabelle namens `crontab`. – Jeder Cron-Zeitplan verfügt über 5 Felder, die die Zeit darstellen: `minute hour day-of-month month day-of-week` gefolgt vom Befehl. – Beispielsweise führt `30 2 * * * /path/to/script.sh` jeden Tag um 2:30 Uhr ein Skript aus. - Wir verwenden `crontab -l`, um unsere aktiven Cron-Jobs aufzulisten, und `crontab <filename>`, um Zeitpläne aus einer Datei zu laden.
13. Erweiterte Textverarbeitung
Stream-Bearbeitung mit sed
Stellen Sie sich vor, Sie haben eine riesige Datenbank-Dump-Datei und müssen alle Vorkommen einer alten Server-IP-Adresse durch eine neue ersetzen. Wenn Sie es in einem Editor öffnen, friert Ihr Computer möglicherweise ein. Unter Linux bearbeiten wir Textströme im laufenden Betrieb mit `sed` (kurz für „Stream Editor“). - Die grundlegende Syntax ist `sed "s/old/new/g" file.txt` zum Suchen und Ersetzen von Text. – Durch das Hinzufügen des Flags `-i` (in-place) werden die Ersetzungen direkt wieder in der Datei selbst gespeichert, anstatt nur den geänderten Text auf dem Bildschirm auszugeben. **Warum das wichtig ist**: Wenn Sie `sed "s/port=80/port=8080/g" server.conf` ohne `-i` ausführen, wird nur der geänderte Text auf Ihrem Terminalbildschirm gedruckt. Die eigentliche Datei bleibt völlig unverändert. Das Flag `-i` (in-place) ist erforderlich, um die Änderungen direkt wieder in der Datei zu speichern.
Datenextraktion mit awk
Stellen Sie sich vor, Sie erhalten eine große Tabelle, die als einfacher Text gespeichert ist, in der die Spalten durch Kommas oder Leerzeichen getrennt sind und Sie nur die allererste Datenspalte extrahieren müssen. Unter Linux analysieren wir strukturierte Textspalten mit der leistungsstarken Sprache `awk`. - Standardmäßig teilt `awk` Zeilen durch Leerzeichen auf und weist Spalte 1 `$1`, Spalte 2 `$2` usw. zu. – Mit dem Flag `-F` können Sie ein benutzerdefiniertes Trennzeichen angeben (z. B. `-F:` für Doppelpunkte). Beispielsweise extrahiert `awk -F: '{print $1}' /etc/passwd` nur die Benutzernamen aus einer durch Doppelpunkte getrennten Liste. **Warum das wichtig ist**: Wenn Sie `awk '{print $1}' /etc/shadow` ohne `-F:` ausführen, teilt `awk` Zeilen durch Leerzeichen (Standardeinstellung) und nicht durch Doppelpunkte. Da Schattendateizeilen keine Leerzeichen enthalten, wird die gesamte Zeile als einzelnes Feld behandelt und die vollständigen Hash-Details jedes Benutzers gedruckt. Das Flag `-F:` zwingt `awk` dazu, Spalten stattdessen durch Doppelpunkte zu teilen.
Übersetzen und Schneiden von Daten
Stellen Sie sich vor, Sie arbeiten mit einer CSV-Tabelle mit Transaktionsdaten und -namen. Sie möchten nur die erste Spalte (Datumsangaben) extrahieren und den gesamten Text aus Konsistenzgründen in Großbuchstaben umwandeln. Unter Linux können wir leichtgewichtige Parsing-Tools in einer Pipeline kombinieren: – Der Befehl `cut` schneidet bestimmte Spalten aus strukturiertem Text heraus. Beispielsweise teilt `cut -d, -f1` Zeilen durch Kommas auf (`-d,`) und extrahiert die erste Spalte (`-f1`). – Der Befehl `tr` (übersetzen) wandelt Zeichen aus der Standardeingabe um, indem er beispielsweise Kleinbuchstaben durch Großbuchstaben ersetzt (`tr "a-z" "A-Z"`). **Warum das wichtig ist**: Wenn Sie `cut reports.csv` ohne `-d,` und `-f1` ausführen, erhalten Sie: `cut: you must specify a list of bytes, characters, or fields`. Wenn Sie `-f1` angeben, aber `-d,` weglassen, werden standardmäßig Tabulatoren verwendet, was bedeutet, dass eine CSV-Datei nicht geteilt wird, sondern nur die gesamte Zeile gedruckt wird. Das Flag `-d,` definiert das Komma als Spaltentrennzeichen und `-f1` weist es an, nur die erste Spalte zu extrahieren.
14. Umgebung & Benutzer
Verwalten von Umgebungsvariablen
Stellen Sie sich vor, Sie stellen eine Webanwendung bereit und diese muss wissen, ob sie in einer sicheren lokalen „Entwicklungs“-Sandbox ausgeführt oder mit der Live-„Produktions“-Datenbank verbunden werden soll. Unter Linux übergeben wir Konfigurationen wie diese mithilfe von **Umgebungsvariablen** an laufende Programme. - Wir verwenden den Befehl `export`, um eine Variable zu definieren, damit alle von unserer Shell gestarteten Programme sie lesen können. Z. B. `export APP_ENV=production`. - Um den Wert einer Variablen zu überprüfen oder anzuzeigen, stellen wir ihrem Namen ein Dollarzeichen voran: `echo $APP_ENV`.
Archive & Komprimierung (tar)
Stellen Sie sich vor, Sie haben einen Ordner mit 500 Serverprotokollen und möchten ihn per E-Mail an einen Kollegen senden oder im Cloud-Speicher sichern. Das Senden von 500 einzelnen Dateien ist langsam und ineffizient. Unter Linux komprimieren wir sie mit `tar` (kurz für „Tape Archive“) in eine einzige, kompakte ZIP-Datei. - Wir erstellen komprimierte Archive mit den Flags: `-c` (erstellen), `-z` (mit gzip komprimieren), `-v` (ausführliche Auflistung der Dateien) und `-f` (Dateinamen angeben). Beispielsweise bündelt und komprimiert `tar -czvf backup.tar.gz folder/` das Verzeichnis. **Warum das wichtig ist**: Wenn Sie `tar -cz logs.tar.gz logs` ohne `-f` ausführen, erhalten Sie: `tar: Refusing to write archive contents to terminal`. Das Flag `-f` ist von entscheidender Bedeutung, da es `tar` anweist, die Ausgabe in eine Datei zu schreiben, anstatt rohe Binärarchivdaten direkt an Ihr Terminal zu senden. Die Flags `-c` und `-z` sind außerdem erforderlich, um das Archiv zu erstellen bzw. zu komprimieren.
Dateikomprimierung (gzip & gunzip)
Stellen Sie sich vor, Sie haben eine einzelne Textdatei mit einem riesigen Datensatz und möchten deren Größe reduzieren, um Speicherplatz zu sparen oder die Freigabe zu beschleunigen. Unter Linux komprimieren wir einzelne Dateien mit `gzip` und stellen sie mit `gunzip` wieder her. - Der Befehl `gzip <filename>` komprimiert eine Datei und ersetzt sie durch eine komprimierte Version mit der Endung `.gz` (z. B. wird `backup.txt` zu `backup.txt.gz`). – Der Befehl `gunzip <filename.gz>` dekomprimiert die Datei und stellt die Originalversion wieder her.
Archivieren mit zip & unzip
Während `tar` und `gzip` unter Linux Standard sind, ist `zip` das am häufigsten verwendete Archivformat in der Cross-Plattform-Welt (Windows/macOS). Unter Linux verpacken und komprimieren wir Dateien mit `zip` in ZIP-Dateien und extrahieren sie mit `unzip`. - Der Befehl `zip <archive.zip> <files>` erstellt ein Zip-Archiv. - Der Befehl `unzip <archive.zip>` extrahiert die Dateien aus dem Archiv.
Alternative Komprimierung (bzip2 und xz)
Neben `gzip` und `zip` unterstützt Linux andere Komprimierungsformate, die für höhere Komprimierungsraten auf Kosten der CPU-Geschwindigkeit optimiert sind. Dies sind `bzip2` (bz2) und `xz` (xz). – Der Befehl `bzip2 <file>` komprimiert eine Datei und gibt `<file>.bz2` aus. – Der Befehl `xz <file>` verwendet verlustfreie LZMA-Komprimierung, um `<file>.xz` zu erstellen, was zu außergewöhnlich kleinen Dateigrößen führt und sich ideal für Linux-Kernel-Releases eignet.
Untersuchen der Umgebung
Stellen Sie sich vor, Sie versuchen, ein Skript zu debuggen, das immer wieder fehlschlägt, weil es den Pfad eines Programms nicht finden kann, oder Sie möchten sehen, welches Benutzerkonto in diesem Terminal aktiv ist. Unter Linux werden alle diese sitzungsweiten Konfigurationen zusammen gespeichert. – Der Befehl `env` gibt ein vollständiges Verzeichnis aller derzeit in Ihrer aktiven Sitzung geladenen Umgebungsvariablen aus, sodass Sie Konfigurationen auf einmal überprüfen können.
Befehle finden (die)
Nachdem Sie nun mit aktiven Umgebungsvariablen wie `PATH` (der die Verzeichnisse speichert, in denen Linux nach Befehlen sucht) vertraut sind, wie finden Sie den genauen Dateipfad des Programms, das ausgeführt wird, wenn Sie `ls` oder `grep` eingeben? Wir verwenden `which`, um Befehlsbinärdateien zu finden. – Der Befehl `which` durchsucht die in Ihrer Variable `$PATH` aufgeführten Ordner und gibt den absoluten Pfad der Binärdatei aus, die ausgeführt wird, wenn der Befehl ausgeführt wird (z. B. `which ls` gibt `/bin/ls` aus). – Dies ist nützlich, um herauszufinden, wo ein Tool installiert ist, oder um Konflikte zwischen mehreren Versionen desselben Tools zu lösen.
Benutzerdefinierte Shell-Verknüpfungen (Alias)
Das Eingeben langer Befehle mit mehreren Flags kann anstrengend werden. Unter Linux können wir benutzerdefinierte Verknüpfungen erstellen, die Aliase genannt werden. Beispielsweise können Sie `ll` so zuordnen, dass `ls -la` automatisch ausgeführt wird. - Um einen temporären Alias zu erstellen, führen Sie `alias name='command'` aus (z. B. `alias ll='ls -la'`). – Wenn Sie `alias` ohne Argumente ausführen, werden alle aktiven Aliase in der aktuellen Sitzung aufgelistet. – Um Aliase über Neustarts hinweg dauerhaft zu machen, werden sie normalerweise in die Konfigurationsdateien `.bashrc` oder `.bash_profile` geschrieben.
15. Erweitertes Dateisystem
Erstellen von Links (ln -s)
Stellen Sie sich vor, Sie haben eine Konfigurationsdatei tief in einem verschachtelten Ordner, sagen wir `/var/www/html/configs/app/settings.conf`, aber Sie müssen sie ständig bearbeiten. Anstatt jedes Mal den langen Ordnerpfad einzugeben, möchten Sie eine schnelle Desktop-Verknüpfung. Unter Linux tun wir dies, indem wir Links erstellen. - **Hard Link**: Ein direkter Klon, der auf die Rohdaten der Datei verweist. Wenn Sie die Originaldatei löschen, funktioniert der Link weiterhin. - **Symbolischer Link (Soft Link)**: Eine pfadbasierte Verknüpfung (genau wie Windows-Verknüpfungen). Wenn Sie die Originaldatei löschen, wird die Verknüpfung unterbrochen. Wir erstellen sie mit `ln -s target link_name`. **Warum das wichtig ist**: Wenn Sie `ln logs/app.log app_link.log` ohne `-s` ausführen, erstellen Sie einen festen Link anstelle einer symbolischen Verknüpfung. Wenn sich die Dateien auf verschiedenen Festplattenpartitionen befinden, erhalten Sie: `ln: failed to create hard link: Invalid cross-device link`. Das Flag `-s` erstellt einen flexiblen symbolischen Link (Verknüpfung), der über verschiedene Laufwerke und Verzeichnisse hinweg funktioniert.
Suchergebnisse verarbeiten (xargs)
Stellen Sie sich vor, Sie hätten eine Suche durchgeführt, bei der 100 temporäre Dateien gefunden wurden, und Sie möchten diese nun alle löschen. Die Suchausgabe ist lediglich eine Liste von Textnamen auf Ihrem Bildschirm – wie geben Sie diese Namen als direkte Eingaben an den Löschbefehl ein? Unter Linux schließen wir diese Lücke mit `xargs`. - Der Befehl `xargs` (Argumente ausführen) übernimmt Standardeingabezeilen (wie die Dateiliste von `find`) und gibt sie einzeln als Argumente an einen anderen Befehl weiter. – Beispielsweise findet `find . -name "*.tmp" | xargs rm` alle temporären Dateien und entfernt sie alle in einem einzigen Durchlauf.
16. Fernzugriff & Benutzerverwaltung
Benutzerverwaltung (useradd & passwd)
Bisher haben Sie als Benutzer `learner` gearbeitet. Auf realen Servern müssen Systemadministratoren jedoch mehrere Konten verwalten. Erfahren Sie, wie Sie neue Benutzer hinzufügen und ihre Passwörter festlegen. - Der Befehl `useradd` erstellt ein brandneues Benutzerkonto. Da das Erstellen von Konten Auswirkungen auf die Systemsicherheit hat, muss es mit Superuser-Berechtigungen ausgeführt werden (z. B. `sudo useradd deployer`). – Der Befehl `passwd` legt das Passwort eines Benutzers fest oder ändert es. Führen Sie es als `sudo passwd deployer` aus, um das Kennwort des Deployer-Benutzers festzulegen.
Benutzer verwalten (adduser & userdel)
Während `useradd` ein Low-Level-Dienstprogramm ist, das lediglich Benutzerdetails in Systemkonfigurationsdateien registriert, stellen Debian/Ubuntu-Systeme ein High-Level-interaktives Skript namens `adduser` zur Verfügung, das die Erstellung von Home-Ordnern, das Festlegen von Passwörtern und die Initialisierung von Shell-Umgebungen automatisiert. Umgekehrt löscht `userdel` Benutzerkonten sauber. - Das Ausführen von `sudo adduser tester` führt Sie interaktiv durch die Benutzerkonfiguration. – Durch das Ausführen von `sudo userdel tester` wird das Benutzerkonto gelöscht.
Anzeigen von Benutzeridentitäten (id)
Bei der Fehlerbehebung bei Berechtigungsfehlern müssen Sie den genauen Benutzer- und Gruppen-ID-Kontext überprüfen, unter dem Sie ausgeführt werden. Wir tun dies mit `id`. - Beim Ausführen von `id` werden die Benutzer-ID (UID), die primäre Gruppen-ID (GID) und alle zusätzlichen Gruppenlisten des aktuellen Benutzers gedruckt. – Beim Ausführen von `id <username>` werden Informationen für einen bestimmten Benutzer abgefragt.
Gruppenverwaltung (groupadd & groups)
Unter Linux sind Benutzer in **Gruppen** organisiert, um Berechtigungen einfach zu teilen. Beispielsweise könnten alle Entwickler einer Gruppe mit dem Namen `developers` angehören. Dadurch können wir Dateien gleichzeitig mit dem gesamten Team teilen. - Der Befehl `groupadd` erstellt eine neue Gruppe. Da es sich um eine Systemkonfiguration handelt, sind Superuser-Rechte erforderlich (z. B. `sudo groupadd developers`). – Der Befehl `groups [username]` listet alle Gruppen auf, denen ein Benutzer angehört. Wird ohne Argumente ausgeführt und zeigt Gruppen für den aktuellen Benutzer an.
Löschen von Gruppen (groupdel)
Wenn Projektteams Dienste neu organisieren oder außer Betrieb nehmen, müssen die entsprechenden Sicherheitsgruppen bereinigt werden. Unter Linux löschen wir Gruppen mit `groupdel`. – Der Befehl `groupdel <group_name>` löscht eine Gruppe dauerhaft aus den Systemkonfigurationsdateien und erfordert Superuser-Rechte.
Sicherheitskontexte wechseln (su)
Nachdem Sie nun das Konto `deployer` erstellt haben, wie melden Sie sich lokal an, um seine Umgebung zu testen? Unter Linux verwenden wir den Befehl `su` (substitute user), um Konten zu wechseln, ohne uns abzumelden. – Der Befehl `su <username>` schaltet die aktuelle Terminal-Shell auf die Sitzung dieses Benutzers um. – Bei der Umstellung wird beim Ausführen von `whoami` der neue Benutzername angezeigt. - Um zu Ihrer ursprünglichen Benutzerkontositzung zurückzukehren, geben Sie `exit` ein oder drücken Sie `Ctrl+D`.
Secure Shell Access (ssh)
Der lokale Wechsel von Benutzern ist nützlich, aber beim Cloud Computing befinden sich Server in entfernten Rechenzentren. Um eine sichere Verbindung über das Netzwerk herzustellen, verwenden wir `ssh` (Secure Shell). – Der Befehl `ssh` verschlüsselt die Verbindung zwischen Ihrem Computer und einem Remote-Host, um Abhören zu verhindern. - Syntax: `ssh user@hostname` oder `ssh user@ip_address` (z. B. `ssh admin@192.168.1.100`). - Bei der ersten Verbindung werden Sie aufgefordert, die Authentizität des Remote-Hosts durch Anzeige eines eindeutigen ECDSA-Fingerabdrucks zu überprüfen. **Hinweis:** Da es sich um eine browserbasierte Sandbox handelt, gibt es keinen echten Remote-Server, zu dem eine Verbindung hergestellt werden kann. Wenn Sie diesen Befehl ausführen, wird Ihnen sofort das erwartete reale Ausgabemuster (Hostüberprüfung, Verbindung, Sitzung) angezeigt, und nicht eine tatsächliche interaktive Live-Sitzung. In einem echten Terminal würde ssh Sie in eine wirklich separate Remote-Shell versetzen, bis Sie `exit` eingeben.
Secure File Transfer (scp)
Nachdem Sie nun wissen, wie Sie sich über SSH bei einem Remote-Server anmelden, wie kopieren Sie eine lokale Datei (z. B. ein Backup-Archiv) darauf? Der Befehl `scp` (sichere Kopie) kopiert Dateien mithilfe von SSH unter der Haube sicher zwischen Hosts. - Die Syntax ist `scp source_path user@host:destination_path`. - Beispielsweise kopiert `scp log.txt admin@192.168.1.100:/tmp/` die lokale Datei `log.txt` in den Remote-Ordner `/tmp/`. **Hinweis:** Genau wie bei ssh gibt es hier keinen echten Remote-Server. Wenn Sie diesen Befehl ausführen, wird die Existenz Ihrer lokalen Datei bestätigt und die erwartete Übertragungsausgabe angezeigt, es werden jedoch keine Daten gesendet.
Who Am I and Where Am I?.
Befehlsübersicht
Überprüfungs-Checkliste
Aufgedeckte Hinweise
File Explorer
Was ist BashQuest?
Kostenlose Online-Übungsplattform und spielerisches Bash-Lernsystem. Führen Sie echte Befehle in einem simulierten Dateisystem mit sofortiger Validierung aus.
Was ist BashQuest?
BashQuest ist eine kostenlose Online-Plattform zum praktischen Erlernen von Linux-Terminalbefehlen. Anders als bei passiven Videokursen lernen Sie hier durch direktes Tippen und Ausführen von Befehlen im Browser.
BashQuest bietet eine vollständige Terminal-Simulation mit strukturierten Lernzielen – 100% sicher und direkt im Browser.
Warum dieses Projekt entstand
Als ich anfing, Linux zu lernen, hatte ich Angst, mein System durch falsche Befehle zu beschädigen. Ich wollte eine risikofreie Umgebung schaffen, in der jeder ohne Installation sofort loslegen kann.
Durch das selbstständige Eintippen, Lesen der Ausgaben und Lösen von Fehlern baut sich echtes Muskelgedächtnis auf.
Kostenloses Online-Terminal-Training mit direktem Feedback
Man lernt Linux am schnellsten durch unmittelbare Praxis. BashQuest bietet ein interaktives Terminal mit sofortiger Rückmeldung auf jede Eingabe.
Ein virtuelles Linux-Terminal für effektives Lernen
BashQuest bietet eine vollständige Terminal-Simulation mit strukturierten Lernzielen – 100% sicher und direkt im Browser.
Warum praktisches Training den Lernerfolg steigert
Durch das selbstständige Eintippen, Lesen der Ausgaben und Lösen von Fehlern baut sich echtes Muskelgedächtnis auf.
Was Sie lernen werden
Unser modularer Lehrplan deckt 16 Kernbereiche der Linux-Administration ab:
Dateisystem-Grundlagen
Dateimanipulation
Pipes & Filterung
Umleitung & Sicherheit
Superuser & Paketverwaltung
Festplatte & Systemressourcen
Prozessverwaltung
Netzwerk-Fehlerbehebung
Dateisuche & Finden
Dienste & Systemd
Terminal-Textbearbeitung
Shell-Skripting & Automatisierung
Erweiterte Textverarbeitung
Umgebung & Benutzer
Erweitertes Dateisystem
Fernzugriff & Benutzerverwaltung
Linux Web-Werkzeuge & Hilfsprogramme
Interaktive Werkzeuge zur Chmod-Rechteberechnung, Cron-Erstellung, Regex-Prüfung und Befehlssuche.
Chmod calculator
Octal & symbolic output
chmod 000 [file]Cron job explainer
Plain-English translation
Command synthesizer
Pick a task, get the command
Select a task above to see the command.
—