// Ratgeber · Linux · Grundlagen

Die wichtigsten Linux-Befehle: Referenz für den Client und Serveralltag

📅 19.09.2026 ⏱ 20 Min. Lesezeit

Man muss nicht hunderte Befehle auswendig kennen. Es reicht, etwa dreißig sicher zu beherrschen und für den Rest zu wissen, wo man nachschaut. Dieser Artikel ist deshalb keine Liste zum Auswendiglernen, sondern eine Referenz zum Nachschlagen: nach Aufgaben sortiert, mit Beispielen, einer Handvoll Praxis-Rezepten für typische Serverprobleme – und einer Warnliste der Befehle, die man niemals blind tippt.

Notation & Tastenkürzel

Damit die Tabellen lesbar bleiben, gelten hier diese Konventionen:

Schreibweise	Bedeutung
`befehl [option] ziel`	Eckige Klammern sind optional – du lässt sie weg, sie sind keine Eingabe.
`platzhalter`	Ein Name, den du ersetzt: `datei`, `dienst`, `host`.
`sudo`	Führt den Befehl als Root aus. Nie „vorsichtshalber“ überall davorsetzen.
`\|`	Pipe: die Ausgabe links wird Eingabe rechts (`ps aux \| grep nginx`).
`>` und `>>`	Ausgabe in Datei schreiben – überschreibt bzw. hängt an.

# -> das ist kein Befehl, sondern ein Kommentar fuer dich
sudo systemctl restart nginx    # als Root neu starten

Diese Tastenkürzel sparen im Terminal mehr Zeit als jeder Befehl:

Tasten	Wirkung
`Tab`	Autovervollständigung von Befehlen und Pfaden – dein wichtigster Schutz vor Tippfehlern.
`Ctrl` + `C`	Bricht den laufenden Befehl ab.
`Ctrl` + `D`	Sendet „Dateiende“ – beendet auch eine Shell-Sitzung.
`Ctrl` + `Z`	Stoppt den Befehl und legt ihn in den Hintergrund (`fg` holt ihn zurück).
`Ctrl` + `R`	Befehlshistorie durchsuchen – tippe ein Fragment, z. B. `systemct`.
`Ctrl` + `L`	Bildschirm leeren (entspricht `clear`).
`Ctrl` + `U` / `K`	Zeile vor bzw. ab dem Cursor löschen.
`Ctrl` + `A` / `E`	An den Zeilenanfang bzw. das Zeilenende springen.

Zwei Ausrufezeichen: !! wiederholt den letzten Befehl, sudo !! führt ihn mit Root-Rechten aus – der Klassiker, wenn du sudo vergessen hast. Mit !$ setzt du das letzte Argument ein (mkdir test && cd !$).

Die Basics: 12 Befehle für alles

Wenn du nur eine Handvoll Befehle mitnimmst, dann diese:

Befehl	Was er tut	Beispiel
`ls -lah`	Dateien auflisten: lang, alle (auch versteckte), lesbare Größen	`ls -lah /etc/nginx`
`cd`	Verzeichnis wechseln. `-` springt zur vorherigen Position	`cd /var/log && cd -`
`cat` / `less`	Datei ausgeben bzw. seitenweise lesen	`less /etc/ssh/sshd_config`
`cp` / `mv`	Kopieren bzw. verschieben/umbenennen	`cp -a config config.bak`
`rm`	Löschen. `-r` rekursiv, `-i` fragt nach	`rm -i notiz.txt`
`grep`	In Dateien oder Ausgaben suchen	`grep -rn 'Listen' /etc/apache2`
`find`	Nach Dateien suchen (Name, Größe, Alter)	`find /var/log -name '*.log' -mtime +30`
`du` / `df`	Platzverbrauch von Ordnern bzw. freien Platz auf Platten	`df -h`
`ps` / `top`	Laufende Prozesse ansehen	`ps aux --sort=-%mem \| head`
`systemctl`	Dienste starten, stoppen, Status prüfen	`systemctl status nginx`
`journalctl`	Logs des Systems und der Dienste lesen	`journalctl -u nginx -n 50`
`man`	Handbuchseite lesen – die Antwort auf fast alles	`man rsync`

Finde deinen Weg zurück: Wenn du dich verrannt hast, hilft dieser Dreiklang fast immer: df -h (Platte voll?), systemctl --failed (Dienst kaputt?), journalctl -p err -b (was ist seit dem Start schiefgelaufen?).

Dateien & Verzeichnisse

Befehl	Bedeutung	Beispiel
`pwd`	„print working directory“ – wo bin ich?	`pwd`
`mkdir -p`	Ordner anlegen, inklusive fehlender Elternordner	`mkdir -p /opt/stacks/nginx`
`touch`	Leere Datei anlegen oder Zeitstempel aktualisieren	`touch .env`
`cp -a`	Kopieren mit Rechten, Besitzer und Zeitstempeln	`cp -a site/ site.backup/`
`rsync -av`	Intelligentes Kopieren – ideal für große Ordner	`rsync -av --dry-run quelle/ ziel/`
`mv`	Verschieben oder umbenennen	`mv alt.conf neu.conf`
`ln -s`	Symbolischen Link erzeugen	`ln -s /opt/app/current /var/www/html`
`stat`	Alle Metadaten einer Datei (Rechte, Zeit, Inode)	`stat /etc/passwd`
`file`	Dateityp bestimmen – auch ohne Endung	`file unbekannt.bin`
`readlink -f`	Link auflösen und den echten Pfad zeigen	`readlink -f /var/www/html`
`tree -L 2`	Verzeichnisbaum anzeigen (Paket `tree`)	`tree -L 2 /opt/stacks`
`basename` / `dirname`	Nur Dateiname bzw. nur Pfad aus einem Pfad ziehen	`basename /etc/nginx/nginx.conf`

Der Schlussstrich bei rsync ist wichtig: quelle/ (mit Schrägstrich) kopiert den Inhalt, quelle (ohne) kopiert den Ordner selbst in das Ziel. Der zweithäufigste Fehler ist --delete: Das löscht im Ziel alles, was in der Quelle fehlt – teste damit immer zuerst mit --dry-run.

Ansehen & Bearbeiten

Befehl	Bedeutung	Beispiel
`less`	Seitenweise lesen. `/wort` sucht, `n` springt weiter, `G` ans Ende, `q` beendet	`less -S /var/log/syslog`
`head -n 20`	Die ersten 20 Zeilen	`head -n 20 config.yml`
`tail -n 50`	Die letzten 50 Zeilen	`tail -n 50 /var/log/nginx/error.log`
`tail -f`	Datei „mitlesen“ – perfekt für Logs	`tail -f /var/log/nginx/access.log`
`wc -l`	Zeilen zählen	`wc -l /var/log/nginx/access.log`
`nl`	Ausgabe mit Zeilennummern	`nl script.sh`
`nano`	Einsteiger-Editor. `Ctrl`+`O` speichern, `Ctrl`+`X` beenden, `Ctrl`+`W` suchen	`nano /etc/hosts`
`vim`	Mächtiger Editor. `i` = einfügen, `Esc`, `:wq` = speichern+schließen, `:q!` = verwerfen	`vim /etc/fstab`
`diff`	Zwei Dateien vergleichen	`diff -u nginx.conf.bak nginx.conf`
`tee`	Ausgabe gleichzeitig anzeigen und in eine Datei schreiben	`echo 'text' \| sudo tee -a /etc/hosts`

Vor jeder Änderung eine Kopie: sudo cp datei datei.$(date +%F).bak. Das dauert eine Sekunde und hat schon viele Abende gerettet – der Zeitstempel im Namen verhindert, dass du ein Backup überschreibst.

Suchen & Textverarbeitung

Befehl	Bedeutung	Beispiel
`grep -rn`	Rekursiv suchen und Zeilennummern zeigen	`grep -rn 'Listen 80' /etc/apache2`
`grep -i`	Suche ohne Groß-/Kleinschreibung	`grep -i error /var/log/syslog`
`grep -v`	Zeilen ohne den Treffer (aussortieren)	`grep -v '^#' sshd_config`
`grep -rl`	Nur Dateinamen ausgeben, die den Treffer enthalten	`grep -rl 'alte-domain.de' /etc/nginx`
`grep -E`	Erweiterte reguläre Ausdrücke (`\|`, `+`, `?`)	`grep -E 'error\|failed' log`
`find -name`	Nach Namen suchen	`find / -xdev -name 'id_ed25519*'`
`find -size +1G`	Nach Größe suchen	`find / -xdev -type f -size +1G 2>/dev/null`
`find -delete`	Sofort löschen – erst mit `-print` prüfen!	`find /var/log -name '*.gz' -mtime +90 -print`
`sed -i`	Ersetzen direkt in der Datei	`sed -i.bak 's/8080/80/g' config.yml`
`awk`	Spaltenweise auswerten	`awk -F: '{print $1}' /etc/passwd`
`cut -d: -f1`	Spalten nach Trennzeichen herausschneiden	`cut -d: -f1,3 /etc/passwd`
`sort` / `sort -h`	Sortieren, `-h` versteht Größen wie `1K`, `4M`	`sort -h datei`
`uniq -c`	Doppelte Zeilen zählen – vorher `sort`!	`sort log \| uniq -c \| sort -rn \| head`
`tr`	Zeichen ersetzen oder löschen	`tr 'a-z' 'A-Z' < datei`
`xargs`	Ausgabe als Argumente weitergeben	`grep -rl alt . \| xargs sed -i 's/alt/neu/g'`
`jq`	JSON lesbar filtern (Paket `jq`)	`jq -r '.name' paket.json`

„Kein Platz mehr“, obwohl Platz frei ist: Oft fehlen keine Bytes, sondern Inodes – also sehr viele kleine Dateien. df -i zeigt es. Typische Verursacher: Session-Dateien, Log-Fragmente, Cache-Verzeichnisse.

Rechte & Besitzer

Linux-Rechte sind drei Buchstaben für drei Gruppen: Besitzer, Gruppe, alle anderen. Jeder Buchstabe hat einen Zahlenwert.

Wert	Recht	Bedeutung bei
`4`	`r` – read	Datei lesen / Ordner auflisten
`2`	`w` – write	Datei ändern / Ordner befüllen
`1`	`x` – execute	Programm starten / Ordner betreten

Befehl	Bedeutung	Beispiel
`chmod 644`	Standard für Dateien: Besitzer schreibt, alle lesen	`chmod 644 index.html`
`chmod 600`	Nur der Besitzer darf lesen und schreiben	`chmod 600 ~/.ssh/id_ed25519`
`chmod 755`	Standard für Verzeichnisse und Skripte	`chmod 755 /usr/local/bin/script.sh`
`chmod u+x`	Ausführbar machen (symbolisch)	`chmod u+x backup.sh`
`chmod -R`	Rekursiv – besonders vorsichtig verwenden	`chmod -R u=rwX,go=rX webroot`
`chown user:gruppe`	Besitzer und Gruppe setzen	`chown www-data:www-data webroot`
`chown -R`	Rekursiv – der häufigste Fehler mit Folgen	`chown -R www-data /var/www/site`
`umask`	Standardrechte für neue Dateien (022 = 644/755)	`umask`
`id` / `groups`	Eigene UID/GID und Gruppenmitgliedschaften	`id www-data`
`sudo -u user`	Befehl als ein bestimmter Nutzer ausführen	`sudo -u www-data php artisan cache:clear`
`setfacl`	Erweiterte Rechte über die Gruppen hinaus	`setfacl -m u:backup:rX /srv/daten`
`lsattr`	Dateisystem-Attribute ansehen	`lsattr /etc/hosts`

Das X in u=rwX,go=rX kennt den Unterschied: Es setzt das Ausführbar-Bit nur bei Verzeichnissen und bereits ausführbaren Dateien. Damit verhinderst du, dass eine Textdatei durch ein rekursives chmod +x zum „Programm“ wird.

Prozesse

Befehl	Bedeutung	Beispiel
`ps aux`	Alle laufenden Prozesse	`ps aux \| grep nginx`
`ps --sort`	Sortiert – wer frisst Speicher?	`ps aux --sort=-%mem \| head`
`pgrep -a`	Prozess-IDs zu einem Namen finden (mit Befehl)	`pgrep -af node`
`top` / `htop`	Live-Übersicht: Last, Speicher, Prozesse	`htop`
`kill -15 PID`	Bittet den Prozess zu beenden (SIGTERM) – immer zuerst	`kill -15 1234`
`kill -9 PID`	Erzwingt das Ende (SIGKILL) – keine Aufräumarbeit mehr	`kill -9 1234`
`pkill -f`	Nach Kommandozeile beenden statt PID	`pkill -f 'python manage.py'`
`nice` / `renice`	Priorität eines Prozesses senken oder ändern	`nice -n 10 tar -czf …`
`lsof -i :80`	Welcher Prozess benutzt diesen Port?	`sudo lsof -i :80`
`lsof +L1`	Gelöschte, aber noch offene Dateien – klassische Ursache für „Platte voll“	`sudo lsof +L1 \| head`
`nohup … &`	Befehl läuft weiter, wenn die Sitzung endet	`nohup ./script.sh > log 2>&1 &`
`jobs` / `fg` / `bg`	Hintergrundjobs ansehen und zurückholen	`jobs -l`

Erst -15, dann -9: SIGTERM gibt Programmen die Chance, offene Dateien zu schreiben und Verbindungen zu schließen. kill -9 ist ein Notaus – danach kann ein Dienst in einem halbfertigen Zustand zurückbleiben.

Dienste: systemd & Logs

Befehl	Bedeutung	Beispiel
`systemctl status`	Zustand, letzte Logzeilen, aktiver Prozess	`systemctl status nginx --no-pager`
`systemctl restart`	Dienst komplett neu starten	`sudo systemctl restart nginx`
`systemctl reload`	Konfiguration neu laden, ohne zu unterbrechen	`sudo systemctl reload nginx`
`systemctl enable --now`	Dienst sofort starten und beim Boot aktivieren	`sudo systemctl enable --now docker`
`systemctl list-units --failed`	Was ist gerade kaputt?	`systemctl --failed`
`systemctl list-timers`	Alle Timer und ihre nächsten Laufzeiten	`systemctl list-timers --all`
`systemctl cat`	Die Unit-Datei anzeigen (inkl. Overrides)	`systemctl cat nginx`
`systemctl edit`	Ergänzungen schreiben, ohne die Originaldatei anzufassen	`sudo systemctl edit nginx`
`journalctl -u`	Logs genau eines Dienstes	`journalctl -u ssh -n 100 --no-pager`
`journalctl -f`	Logs live mitlesen	`journalctl -fu nginx`
`journalctl -p err -b`	Nur Fehler seit dem letzten Boot	`journalctl -p err -b`
`journalctl --since`	Zeitraum eingrenzen	`journalctl --since "1 hour ago" -u ssh`
`journalctl --disk-usage`	Wie viel Platz belegen die Logs?	`journalctl --vacuum-time=7d`
`crontab -e`	Zeitgesteuerte Aufgaben des eigenen Nutzers	`crontab -l`
`timedatectl`	Zeit, Zeitzone und NTP-Status	`timedatectl status`

Timer statt Cron: Für Serveraufgaben sind systemd-Timer die bessere Wahl – sie können verpasste Läufe nachholen (Persistent=true) und nur starten, wenn ein Datenträger gemountet ist (RequiresMountsFor=). Beides kannst du in crontab nicht ausdrücken.

Paketverwaltung (apt)

Befehl	Bedeutung	Beispiel
`apt update`	Paketlisten aktualisieren (installiert nichts!)	`sudo apt update`
`apt full-upgrade`	Alle Pakete aktualisieren, auch mit Abhängigkeitsänderungen	`sudo apt full-upgrade`
`apt install`	Paket installieren	`sudo apt install htop`
`apt remove` / `purge`	Entfernen bzw. entfernen inklusive Konfiguration	`sudo apt purge altes-paket`
`apt autoremove --purge`	Nicht mehr benötigte Abhängigkeiten entfernen	`sudo apt autoremove --purge`
`apt list --upgradable`	Was wäre aktualisierbar?	`apt list --upgradable`
`apt-cache search`	Nach Paketen suchen	`apt-cache search fail2ban`
`apt show`	Details, Version, Abhängigkeiten	`apt show nginx`
`dpkg -l`	Installierte Pakete auflisten	`dpkg -l \| grep -c '^ii'`
`dpkg -S`	Zu welchem Paket gehört diese Datei?	`dpkg -S /usr/bin/curl`
`apt-mark hold`	Paket von Updates ausnehmen	`sudo apt-mark hold linux-image-amd64`
`needrestart`	Zeigt, welche Dienste nach Updates neu starten müssen	`sudo needrestart -r l`

apt update ≠ apt upgrade: Der erste Befehl holt nur die Listen, installiert aber nichts. Und: Ein Kernel-Update wird erst nach einem Neustart aktiv – wenn du monatelang nicht rebootest, läuft weiter der alte Kernel mit den alten Lücken.

Netzwerk & Ports

Befehl	Bedeutung	Beispiel
`ip -br a`	Alle Netzwerkgeräte mit IP-Adressen, kurz und lesbar	`ip -br a`
`ip -br r`	Routing-Tabelle – wohin geht der Verkehr?	`ip r get 1.1.1.1`
`ip neigh`	Bekannte Nachbarn im lokalen Netz (ARP)	`ip neigh show`
`ss -tulpen`	Alle offenen Ports, Prozess und Nutzer dazu	`sudo ss -tulpen`
`ss -tan state established`	Nur aktive Verbindungen	`ss -tan state established`
`ping -c 4`	Erreichbarkeit prüfen (4 Pakete, dann Ende)	`ping -c 4 1.1.1.1`
`dig +short`	DNS-Auflösung prüfen – die Wahrheit statt Browser-Cache	`dig +short MX meine.domain`
`curl -I`	Nur die HTTP-Header einer URL anzeigen	`curl -I https://meine.domain`
`curl -w`	Statuscode und Zeit messen	`curl -sS -o /dev/null -w '%{http_code}\n' URL`
`wget -c`	Datei herunterladen, abgebrochene fortsetzen	`wget -c https://…/datei.iso`
`nc -zv`	Testen, ob ein Port offen ist	`nc -zv host 22`
`traceroute`	Welchen Weg nehmen die Pakete?	`traceroute -T meine.domain`
`tcpdump`	Pakete mitschneiden (nur für Diagnose)	`sudo tcpdump -ni any port 53`
`ufw status`	Regeln der einfachen Firewall anzeigen	`sudo ufw status verbose`
`nft list ruleset`	Die tatsächlich aktiven Firewall-Regeln	`sudo nft list ruleset`

Die drei Fehlerquellen in Reihenfolge prüfen: Erst DNS (dig +short meine.domain), dann Port (nc -zv host 443), dann Anwendung (curl -I https://…). So findest du in 60 Sekunden, ob es die Namensauflösung, die Firewall oder der Webserver ist.

Platten, Speicher & SMART

Befehl	Bedeutung	Beispiel
`df -h`	Freier Platz aller Dateisysteme	`df -h /var`
`df -i`	Inodes – „kein Platz“, obwohl Bytes frei sind	`df -i`
`du -sh`	Größe eines Ordners (Gesamtsumme)	`du -sh /var/log`
`du --max-depth`	Größen der Unterordner sortiert	`du -h --max-depth=1 /var \| sort -h`
`lsblk -f`	Platten, Partitionen, Dateisysteme, Mountpunkte	`lsblk -f`
`blkid`	UUIDs der Dateisysteme (für `/etc/fstab`)	`sudo blkid`
`findmnt`	Ist dieser Ordner wirklich ein Mount?	`findmnt /mnt/backup`
`mount` / `umount`	Ein- und aushängen	`sudo umount /mnt/backup`
`fuser -m`	Wer blockiert das Aushängen?	`sudo fuser -vm /mnt/backup`
`free -h`	RAM- und Swap-Belegung	`free -h`
`swapon --show`	Aktive Swap-Bereiche bzw. -Dateien	`swapon --show`
`smartctl -a`	Gesundheit der Festplatte (Paket `smartmontools`)	`sudo smartctl -a /dev/sda`
`smartctl -t short`	Schneller Selbsttest der Platte	`sudo smartctl -t short /dev/sda`
`ncdu`	Interaktive Platz-Analyse (Paket `ncdu`)	`ncdu /var`

Die df-Ausgabe kann lügen: Sie zeigt dir nur, was eingehängt ist. Wenn eine Platte nicht gemountet wurde, schreibt dein Backup auf die Systemplatte und füllt sie. Deshalb bei Automatismen immer findmnt /mnt/backup bzw. RequiresMountsFor= voranschalten.

Benutzer, SSH & Dateitransfer

Befehl	Bedeutung	Beispiel
`whoami` / `id`	Wer bin ich und welche Rechte habe ich?	`id`
`adduser`	Neuen Benutzer anlegen (interaktiv, legt Home an)	`sudo adduser maria`
`usermod -aG`	Benutzer zu einer Gruppe hinzufügen (`-a` nicht vergessen!)	`sudo usermod -aG sudo maria`
`passwd`	Passwort setzen oder ändern	`sudo passwd -l maria`
`userdel -r`	Benutzer inklusive Home löschen	`sudo userdel -r altes-konto`
`who` / `w`	Wer ist gerade angemeldet?	`w`
`last -n 20`	Letzte Anmeldungen – prüfe, wer da war	`last -n 20`
`ssh-keygen -t ed25519`	Modernes Schlüsselpaar erzeugen	`ssh-keygen -t ed25519 -C "maria@server"`
`ssh-copy-id`	Öffentlichen Schlüssel auf den Zielserver bringen	`ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host`
`ssh -p`	Verbindung mit Port und Schlüssel	`ssh -p 2222 -i ~/.ssh/id_ed25519 user@host`
`scp -r`	Dateien/Ordner rekursiv kopieren	`scp -r site/ user@host:/srv/`
`rsync -avz`	Synchronisieren – schneller und wiederholbar	`rsync -avz --dry-run site/ user@host:/srv/site/`
`sshfs`	Entfernten Ordner lokal einhängen	`sshfs user@host:/srv /mnt/remote`
`sftp`	Interaktiver Dateitransfer über SSH	`sftp user@host`

Ein Eintrag in ~/.ssh/config erspart dir jeden Tag Tipparbeit:

Host srv
    HostName 203.0.113.10
    User maria
    Port 2222
    IdentityFile ~/.ssh/id_ed25519

# Kurzform danach:
ssh srv
rsync -av site/ srv:/srv/site/

Verwechselte Argument-Reihenfolge ist ein Klassiker: Bei rsync und scp steht die Quelle zuerst. rsync -av local/ srv:/ziel/ schiebt hoch, rsync -av srv:/ziel/ local/ zieht herunter. Mit --dry-run siehst du vorher, was passieren würde.

Archive & Kompression

Befehl	Bedeutung	Beispiel
`tar -czf`	gzip-Archiv erstellen (c=create, z=gzip, f=Datei)	`tar -czf site.tar.gz /srv/site`
`tar -xzf`	gzip-Archiv entpacken	`tar -xzf site.tar.gz -C /tmp`
`tar -tzf`	Archiv nur ansehen, nichts entpacken	`tar -tzf site.tar.gz \| head`
`tar --exclude`	Pfade ausschließen	`tar -czf b.tgz --exclude='*.log' /srv`
`tar -cJf`	Wie oben, aber mit xz – kleinere Dateien, mehr CPU	`tar -cJf site.tar.xz /srv/site`
`gzip -k`	Einzelne Datei komprimieren, Original behalten	`gzip -k dump.sql`
`zcat` / `zless`	Komprimierte Dateien direkt lesen	`zless /var/log/syslog.2.gz`
`zip -r` / `unzip`	Windows-kompatibles Archiv erzeugen bzw. entpacken	`unzip -l archiv.zip`
`xz -T0 -9`	Maximale Kompression auf allen Kernen	`xz -T0 -9 bigfile`
`tar -czf - . \| ssh`	Archiv direkt auf einen anderen Server streamen	`tar -czf - /srv \| ssh srv 'cat > /backup/site.tgz'`
`dd`	Byteweise kopieren – für Images, nicht für Dateien	`dd if=/dev/sda of=/backup/disk.img bs=4M status=progress`

Was ist schneller? lz4 > zstd > gzip > xz – in dieser Reihenfolge nimmt die Geschwindigkeit ab und die Kompressionsrate zu. Für regelmäßige Backups ist zstd fast immer der beste Kompromiss.

System-Info & Diagnose

Befehl	Bedeutung	Beispiel
`uname -a`	Kernel und Architektur – welcher Kernel läuft wirklich?	`uname -r`
`hostnamectl`	Hostname, OS-Version, Kernel, Virtualisierung	`hostnamectl`
`uptime -p`	Laufzeit und Systemlast in Worten	`uptime -p`
`lscpu`	CPU-Details, Kerne, Flags (z. B. AES-NI)	`lscpu \| head`
`lspci -nnk`	PCI-Geräte und die geladenen Treiber	`lspci -nnk \| grep -iA3 vga`
`lsusb`	Angeschlossene USB-Geräte	`lsusb`
`dmidecode -t memory`	Bestückte RAM-Riegel und Slots	`sudo dmidecode -t memory \| head -30`
`dmesg -T`	Kernel-Meldungen mit Zeitstempel	`sudo dmesg -T \| tail -30`
`journalctl -k -b`	Kernel-Logs seit dem letzten Start	`journalctl -k -b -p warning`
`history`	Befehlshistorie	`history \| grep rsync`
`man -k`	Handbuchseiten nach Stichwort durchsuchen	`man -k 'disk usage'`
`BEFEHL --help`	Schnelle Hilfe statt langer Manpage	`rsync --help`

Ein Neustart zeigt, ob es der Kernel war: Meldungen wie „PCIe Bus Error“, „I/O error“ oder „TASK hung for X seconds“ erscheinen nur in dmesg bzw. journalctl -k. Wenn dein Server ohne Log-Eintrag abstürzt, ist die Hardware der erste Verdacht – dann smartctl und einen längeren memtest laufen lassen.

Docker & Compose

Befehl	Bedeutung	Beispiel
`docker ps -a`	Alle Container, auch gestoppte, mit Ports	`docker ps -a --format 'table {{.Names}}\t{{.Status}}'`
`docker logs -f`	Logs eines Containers live mitlesen	`docker logs -f --tail 100 nginx`
`docker exec -it`	In einen laufenden Container hineinschauen	`docker exec -it nginx bash`
`docker inspect`	Komplette Konfiguration als JSON	`docker inspect -f '{{.State.Status}}' nginx`
`docker stats`	Live: CPU, RAM, Netzwerk je Container	`docker stats --no-stream`
`docker system df`	Platzverbrauch von Images, Volumes, Cache	`docker system df`
`docker system prune`	Ungenutztes aufräumen (erst mit `-n` prüfen!)	`docker image prune -a`
`docker compose pull`	Neue Images ziehen, ohne zu starten	`docker compose pull && docker compose up -d`
`docker compose up -d`	Stack starten oder Änderungen übernehmen	`docker compose up -d`
`docker compose ps`	Status des Stacks	`docker compose ps`
`docker compose logs -f`	Logs aller Dienste des Stacks	`docker compose logs -f --tail 50`
`docker compose down`	Stack stoppen und Container entfernen (Volumes bleiben)	`docker compose down`
`docker compose config`	Compose-Datei validieren und fertig aufgelöst anzeigen	`docker compose config -q`

docker compose down -v löscht Volumes – und damit deine Daten. Das -v ist der häufigste Datenverlust in Docker-Umgebungen. Ohne -v bleiben die Volumes erhalten, und ein up -d bringt alles unverändert zurück.

Rezepte für den Alltag

Einzelne Befehle kann man nachschlagen – Kombinationen muss man kennen. Diese sechs decken die häufigsten Serverprobleme ab:

1. Die Platte ist voll – wo?

df -h                                   # welches Dateisystem ist voll?
du -h --max-depth=1 / 2>/dev/null | sort -h | tail -15   # groesste Ordner
sudo lsof +L1                           # geloeschte, noch offene Dateien

2. Wer belegt diesen Port?

sudo ss -tulpen | grep ':80'
sudo lsof -i :80                        # zeigt Prozessname und PID

3. Ein Dienst startet nicht – warum?

systemctl status mein-dienst --no-pager
journalctl -u mein-dienst -n 100 --no-pager
systemd-analyze verify /etc/systemd/system/mein-dienst.service

4. Log live verfolgen und nur Fehler sehen

journalctl -fu nginx | grep --line-buffered -iE 'error|crit|fail'

5. Einen Begriff in vielen Dateien ersetzen

grep -rl 'alte-domain.de' /etc/nginx               # erst: welche Dateien?
grep -rl 'alte-domain.de' /etc/nginx | xargs sed -i.bak 's/alte-domain.de/neu.de/g'
nginx -t && systemctl reload nginx                  # dann testen und neu laden

6. Große und alte Dateien aufspüren

find / -xdev -type f -size +500M -printf '%s\t%p\n' 2>/dev/null | sort -rn | head
find /var/log -type f -name '*.gz' -mtime +90 -print   # erst anzeigen, dann -delete

Das Muster ist immer gleich: Erst schauen (nur ausgeben), dann handeln. -print vor -delete, --dry-run vor --delete, nginx -t vor systemctl reload. Diese Gewohnheit ist mehr wert als jeder Trick-Befehl.

Befehle, die man nicht blind tippt

Linux fragt nicht nach. Diese Befehle sind nicht „gefährlich“, solange du genau weißt, was sie tun – aber ein Tippfehler reicht:

Befehl	Warum gefährlich	Besser
`rm -rf /pfad`	Leere Variablen oder ein Leerzeichen zu viel löschen Unerwartetes	Pfad als Variable immer in Anführungszeichen: `rm -rf "$ZIEL/"`
`rm -rf "$DIR/"` mit leerem `$DIR`	Wird zu `rm -rf /` – der Klassiker in Skripten	`set -u` im Skript und `[ -n "$DIR" ]` prüfen
`chmod -R 777`	Alle dürfen alles ändern – ein gefundenes Fressen für Webshells	Rechte gezielt setzen: `chown -R user:gruppe` plus `chmod 644/755`
`chown -R user /`	Vertauschte Argument-Reihenfolge zerstört die Besitzverhältnisse des Systems	Immer erst `--dry-run`-Äquivalent: mit `ls -l` prüfen, dann auf den konkreten Ordner anwenden
`dd of=/dev/sda`	Schreibt blind über eine ganze Platte, inklusive Partitionstabelle	`lsblk` zur Kontrolle, `status=progress` nutzen, Ziel doppelt prüfen
`> datei`	Überschreibt die Datei sofort mit leerem Inhalt	Zum Anhängen `>>` verwenden
`mkfs / fsck` auf gemounteten Dateisystemen	Zerstört Daten, weil das System parallel schreibt	Erst `umount`, Platte vorher identifizieren
`history` + `Ctrl`+`R`	Ein alter Befehl aus einer anderen Umgebung passt nicht mehr zum Ziel	Befehl nach dem Aufrufen lesen, bevor du Enter drückst

Drei Sekunden, die Schaden verhindern: ① Bei rm, chown -R, dd und > immer erst mit Tab vervollständigen lassen – dann siehst du den echten Pfad. ② In Skripten set -eu setzen, damit abgebrochen wird, wenn eine Variable leer ist. ③ Vor destruktiven Aktionen ein Backup: cp -a datei datei.$(date +%F).bak.

Häufige Probleme (FAQ)

Problem	Lösung
`command not found`	Paket fehlt (`apt install …`) oder der Pfad steht nicht in `$PATH`. Test: `command -v toolname`.
`Permission denied`	Rechte prüfen mit `ls -l`; für Systemänderungen `sudo` – aber genau überlegen, warum es nicht anders geht.
`Text file busy`	Die Datei läuft gerade als Programm. Prozess stoppen (am besten per `systemctl stop`), Datei ersetzen, wieder starten.
`No space left on device`, obwohl `df` Platz zeigt	Inodes prüfen: `df -i`. Häufig sind es sehr viele kleine Dateien in Cache- oder Session-Ordnern.
`Argument list too long`	Zu viele Dateien für ein Kommando. Ausgabe an `xargs -r -n 100` geben oder `find … -exec` nutzen.
`Device or resource busy` beim `umount`	Wer nutzt es? `sudo fuser -vm /mnt/x` oder `sudo lsof +f -- /mnt/x`, dann Prozess beenden.
Terminal „hängt“, reagiert nicht	`Ctrl`+`C` bricht ab. Ohne Wirkung: `Ctrl`+`Z`, dann `bg` oder `kill %1`.
SSH-Login fragt ständig nach Passwort statt Schlüssel	Rechte prüfen: `chmod 700 ~/.ssh`, `chmod 600 ~/.ssh/id_ed25519`, `chmod 644 ~/.ssh/authorized_keys` – ein zu offenes `authorized_keys` wird ignoriert.
Ausgabe landet im falschen Log oder nirgends	Beide Ströme umleiten: `befehl >> log 2>&1`. `1>` ist stdout, `2>` stderr.
Befehl war zu langsam – ich brauche Fortschritt	`dd status=progress`, `rsync -av --info=progress2`, `tar --checkpoint=1000 --checkpoint-action=dot`.

Fazit

Die wichtigsten Linux-Befehle sind keine Sammlung zum Auswendiglernen, sondern ein Werkzeugkasten. Wenn du Dateien, Rechte, Prozesse, Dienste, Logs und Platz im Griff hast, löst du bereits neun von zehn Serverproblemen – und für alles andere gibt es man, --help und die Fehlermeldung, die dir fast immer sagt, wo es klemmt.

Fünf Gewohnheiten, die mehr bringen als zehn weitere Befehle: ① Tab statt Tippen – du siehst den echten Pfad. ② Erst schauen, dann ändern (--dry-run, -print, -t). ③ Vor Einriffen eine Kopie mit Zeitstempel. ④ journalctl -p err -b als erster Blick nach einem Problem. ⑤ set -eu in jedem Skript, das du aufhebst.

📝

HuuuHosting-Redaktion

Open-Source-Tools für den eigenen Server – getestet, dokumentiert und in der Debian-13-Serie Schritt für Schritt erklärt.