Linux-Befehle-Spickzettel — über 200 Befehle nach Aufgabe

-P

physischen Pfad mit aufgelösten Symlinks ausgeben

-L

logischen Pfad ausgeben, Symlinks bleiben (Standard)

pwd

pwd -P

-l

Langformat: Berechtigungen, Besitzer, Größe, Datum

-a

versteckte Punktdateien einschließen

-h

lesbare Größen (mit -l): 4.0K, 12M

-t

nach Änderungszeit sortieren, neueste zuerst

-r

Sortierung umkehren

-S

nach Größe sortieren, größte zuerst

-d

das Verzeichnis selbst auflisten, nicht seinen Inhalt

-1

ein Name pro Zeile

-R

rekursiv in Unterverzeichnisse

ls -lah

ls -ltr

ls -lS | head

ls -ld */

macOS/BSD: Die Flags oben funktionieren unter macOS. Farbe heißt dort -G (neuere macOS-Versionen akzeptieren auch --color).

-L N

höchstens N Ebenen tief

-a

versteckte Dateien einschließen

-d

nur Verzeichnisse

-I pattern

Namen überspringen, die zum Muster passen

tree -L 2 -I 'node_modules|.git'

Auf den meisten Distributionen nicht vorinstalliert: apt install tree / dnf install tree.

-p

übergeordnete Verzeichnisse bei Bedarf anlegen; kein Fehler, wenn es existiert

-m mode

Berechtigungen setzen, z. B. -m 700

-v

jedes angelegte Verzeichnis ausgeben

mkdir -p project/src/components

mkdir -p app/{src,tests,docs}

-p

auch leere übergeordnete Verzeichnisse entfernen

rmdir old-folder

-c

Datei nicht anlegen, wenn sie nicht existiert

-t stamp

eine bestimmte Zeit setzen

-r ref

Zeitstempel einer anderen Datei übernehmen

touch notes.txt

touch -t 202601011200 file

macOS/BSD: GNU touch -d akzeptiert freien Text wie -d '2 days ago'; macOS -d nimmt nur YYYY-MM-DDThh:mm:SS.

-r, -R

Verzeichnisse rekursiv kopieren

-a

Archiv: rekursiv, behält Berechtigungen, Zeiten, Symlinks

-i

vor dem Überschreiben fragen

-n

vorhandene Dateien nie überschreiben

-u

nur kopieren, wenn die Quelle neuer ist (GNU)

-v

jede kopierte Datei ausgeben

cp report.pdf ~/backup/

cp -a site/ /srv/site-backup

cp -i *.conf /etc/myapp/

macOS/BSD: cp unter macOS hat -a, -R, -i, -n, aber kein -u. Bei BSD-cp kopiert ein abschließender Schrägstrich an der Quelle (cp -R src/ dst) den Inhalt von src, nicht src selbst.

-i

vor dem Überschreiben fragen

-n

nie überschreiben

-v

jede Verschiebung ausgeben

-t dir

nach dir verschieben (GNU; praktisch mit xargs)

mv draft.txt final.txt

mv *.jpg photos/

mv -n new.conf /etc/app/app.conf

mv ersetzt eine vorhandene Zieldatei kommentarlos, außer du gibst -i oder -n an.

-i

vor jedem Löschen fragen

-I

einmal fragen, bevor mehr als drei Dateien oder rekursiv gelöscht wird (GNU)

-r

Verzeichnisse samt Inhalt löschen

-f

fehlende Dateien ignorieren, nie nachfragen

-v

jede gelöschte Datei ausgeben

rm old.log

rm -i *.bak

rm -- -weird-name.txt

In der Kommandozeile gibt es keinen Papierkorb und kein Rückgängig. Gelöscht heißt weg.

rm -rf build/

rm -rf -- "${BUILD_DIR:?}/"

Achtung: Keine Rückfrage, kein Rückgängig. Ein verirrtes Leerzeichen (rm -rf / tmp) oder eine leere Variable (rm -rf "$DIR/"*) löscht viel mehr als beabsichtigt. GNU rm weigert sich, / selbst zu löschen (--preserve-root ist Standard), aber nichts schützt /home oder /etc. Führ zuerst ls auf genau diesen Pfad aus.

-s

symbolischer Link (ohne entsteht ein harter Link)

-f

vorhandenen Link ersetzen

-n

vorhandenen Link auf ein Verzeichnis als normale Datei behandeln (mit -f verwenden)

ln -s /opt/app/bin/app /usr/local/bin/app

ln -sfn releases/v2 current

Reihenfolge: zuerst das Ziel, dann der neue Linkname – wie bei cp.

realpath ../config.yml

readlink -f /usr/bin/python3

macOS/BSD: Aktuelles macOS hat sowohl realpath als auch readlink -f; sehr alte Versionen hatten keins von beiden.

-i

MIME-Typ ausgeben (Linux)

-b

kurz: Dateinamen weglassen

file download.bin

file -i notes.txt

macOS/BSD: Unter macOS heißt das MIME-Flag -I (groß); kleines -i bedeutet dort etwas anderes.

-c FORMAT

eigene Ausgabe (GNU): %s Größe, %y mtime, %U Besitzer, %a oktale Rechte, %n Name

stat file.txt

stat -c '%a %U %s %n' *

macOS/BSD: macOS nutzt -f statt -c, mit anderen Buchstaben: stat -f '%Lp %Su %z %N' file.

-d

Verzeichnis statt Datei anlegen

tmp=$(mktemp -d) && trap 'rm -rf "$tmp"' EXIT

-n

alle Zeilen nummerieren

-A

Tabs als ^I und Zeilenenden als $ anzeigen (GNU); macht CRLF-Zeilenenden sichtbar

cat /etc/os-release

cat part1.txt part2.txt > whole.txt

cat -A script.sh | head

macOS/BSD: cat unter macOS hat kein -A; cat -vet liefert dieselbe Ansicht.

tac access.log | head

macOS/BSD: Gibt es unter macOS nicht; nimm tail -r file.

Space / b

Seite vor / zurück

/text

vorwärts suchen; n nächster, N vorheriger Treffer

g / G

zum Anfang / Ende springen

F

der Datei folgen wie tail -f; Ctrl+C zum Stoppen

q

beenden

-N

Zeilennummern anzeigen

-S

lange Zeilen nicht umbrechen (seitwärts scrollen)

less /var/log/syslog

journalctl -u nginx | less -S

-n N

erste N Zeilen (Standard 10)

-c N

erste N Bytes

-n -N

alles außer den letzten N Zeilen (GNU)

head -n 20 data.csv

head -c 512 file.bin | xxd

macOS/BSD: head unter macOS akzeptiert keine negativen Werte.

-n N

letzte N Zeilen (Standard 10)

-n +N

ab Zeile N beginnen

-f

weiter ausgeben, während die Datei wächst

-F

nach Namen folgen, übersteht Logrotation

tail -n 50 app.log

tail -F /var/log/nginx/access.log

tail -n +2 data.csv

Ctrl+O

speichern

Ctrl+X

beenden

Ctrl+W

suchen

Ctrl+K / Ctrl+U

Zeile ausschneiden / einfügen

Alt+U

rückgängig

sudo nano /etc/hosts

Die Kürzelleiste unten am Bildschirm zeigt die Tasten; ^ steht für Ctrl und M- für Alt.

i

Einfügemodus (Text tippen)

Esc

zurück in den Normalmodus

:w / :q / :wq

speichern / beenden / speichern und beenden

:q!

beenden ohne zu speichern

/text

suchen; n für den nächsten Treffer

dd / yy / p

Zeile löschen / Zeile kopieren / einfügen

u / Ctrl+R

rückgängig / wiederholen

vim +42 app.py

-u

Unified-Format (das nutzen patch und git)

-r

Verzeichnisse rekursiv vergleichen

-q

nur melden, ob sich Dateien unterscheiden

-w

alle Leerzeichen ignorieren

-y

nebeneinander

diff -u old.conf new.conf

diff -rq dir1/ dir2/

diff <(sort a.txt) <(sort b.txt)

Text im Browser nebeneinander vergleichen →

-a

anhängen statt überschreiben

make 2>&1 | tee build.log

echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf

printf '%s\n' "$var"

printf '%-12s %6.2f\n' disk 93.5

echo -e und echo -n verhalten sich je nach Shell unterschiedlich; printf verhält sich überall gleich.

xxd image.png | head

hexdump -C file.bin | head

xxd gehört zu den vim-Paketen; hexdump ist in util-linux (bei neueren Debian/Ubuntu in bsdextrautils).

-n N

nur Zeichenketten mit mindestens N Zeichen (Standard 4)

strings -n 8 firmware.bin | less

Unter Linux Teil von binutils.

ls -l deploy.sh

Das erste Zeichen ist der Typ (- Datei, d Verzeichnis, l Symlink). Dann drei Dreiergruppen: Besitzer, Gruppe, alle anderen. r=4, w=2, x=1, also ist rwxr-x--- gleich 750.

rwx mit dem chmod-Rechner in Oktal umrechnen →

-R

auf ein Verzeichnis und alles darin anwenden

-v

jede Änderung melden

chmod 644 index.html

chmod 755 deploy.sh

chmod 600 ~/.ssh/id_ed25519

Oktalmodus mit dem chmod-Rechner ermitteln →

chmod +x script.sh

chmod go-w file

chmod -R u=rwX,go=rX site/

Symbolische und oktale Modi im chmod-Rechner zusammenstellen →

find site/ -type d -exec chmod 755 {} +

find site/ -type f -exec chmod 644 {} +

Achtung: Gibt jedem Benutzer und jedem kompromittierten Dienst auf dem Rechner Schreibzugriff auf den ganzen Baum, macht alle Dateien ausführbar und lässt OpenSSH Schlüssel in einem ~/.ssh mit 777 ablehnen. Auf /etc oder /usr angewendet, kann es sudo und das System lahmlegen. Korrigier stattdessen den Besitz mit chown oder nutze die beiden find-Befehle.

Den restriktivsten Modus wählen, der funktioniert →

-R

rekursiv

user:

mit abschließendem Doppelpunkt ohne Gruppe wird die Gruppe auf die Login-Gruppe des Benutzers gesetzt

sudo chown -R www-data:www-data /var/www/site

sudo chown "$USER": file.txt

Achtung: sudo chown -R auf /, /usr oder /etc löscht setuid-Bits und Besitzverhältnisse, auf die sudo, passwd und Dienste angewiesen sind; meist hilft dann nur eine Neuinstallation. Prüf den Pfad doppelt.

umask

umask 077

Die Maske entfernt Bits: Dateien starten bei 666 und Verzeichnisse bei 777, 022 ergibt also 644 und 755.

-i

Login-Shell als root

-u user

als dieser Benutzer statt als root ausführen

-l

auflisten, was du ausführen darfst

-k

zwischengespeicherte Anmeldedaten verwerfen

sudo systemctl restart nginx

sudo !!

sudo -u postgres psql

-m

einen Eintrag ändern (hinzufügen)

-x

einen Eintrag entfernen

-b

alle ACL-Einträge entfernen

-R

rekursiv

-d

Standard-ACL setzen, die neue Dateien erben

setfacl -m u:alice:rw report.xlsx

getfacl report.xlsx

setfacl -R -m g:devs:rwX /srv/app

Ein + am Ende der Berechtigungsangabe von ls -l bedeutet, dass die Datei eine ACL hat.

sudo chattr +i /etc/resolv.conf

lsattr /etc/resolv.conf

Unterstützt auf ext4, XFS, Btrfs. Erscheint selbst als root „Operation not permitted“, prüf lsattr.

aux

alle Prozesse mit CPU, Speicher, Benutzer (BSD-Stil)

-ef

alle Prozesse mit Eltern-PID (System-V-Stil)

-o

Spalten auswählen

--sort=-%mem

nach Speicher sortieren, höchster zuerst (procps)

ps aux | grep [n]ginx

ps aux --sort=-%mem | head

ps -o pid,ppid,etime,cmd -p 1234

macOS/BSD: ps unter macOS hat kein --sort; nimm ps aux -m (nach Speicher) oder ps aux -r (nach CPU).

P / M

nach CPU / Speicher sortieren (Linux-top)

1

jeden CPU-Kern anzeigen

k

Prozess per PID beenden

q

beenden

-b -n 1

ein einzelner Batch-Snapshot, für Skripte

top -b -n 1 | head -20

macOS/BSD: top unter macOS ist ein anderes Programm: sortieren mit top -o cpu oder top -o mem.

F3 or /

suchen

F4

filtern

F6

Sortierspalte wählen

F9

ein Signal senden (kill)

t

Baumansicht

htop -u www-data

Installieren mit apt install htop / dnf install htop.

-a

vollständige Befehlszeile anzeigen (Linux procps)

-f

gegen die vollständige Befehlszeile prüfen, nicht nur den Namen

-u user

nur Prozesse dieses Benutzers

-x

exakte Übereinstimmung des Namens

pgrep -a nginx

pgrep -f 'python manage.py runserver'

macOS/BSD: Unter macOS bedeutet -a „Vorfahren einschließen“; nimm pgrep -lf, um Namen und Argumente zu sehen.

pkill -f "node server.js"

pkill -HUP nginx

pgrep -af node

Muster sind reguläre Ausdrücke, die irgendwo im Namen passen; pkill node trifft auch nodejs-helper. Vorher mit pgrep prüfen.

(none) / -15 / -TERM

den Prozess bitten, sich sauber zu beenden (Standard)

-9 / -KILL

Beenden erzwingen; nicht abfangbar, kein Aufräumen

-1 / -HUP

viele Daemons laden dann ihre Konfiguration neu

-l

Signalnamen auflisten

kill 1234

kill -9 1234

kill %1

Versuch zuerst ein einfaches kill und gib ihm ein paar Sekunden: -9 überspringt das Aufräumen, sodass temporäre Dateien, Locks und halb geschriebene Daten zurückbleiben können.

killall firefox

Unter Linux steckt das im Paket psmisc.

jobs

bg %1

fg %1

Ctrl+Z hält das Vordergrundprogramm an (es läuft erst nach bg oder fg weiter).

nohup ./server > server.log 2>&1 &

Für alles Langlebige ist ein systemd-Dienst (siehe Dienste & Logs) oder tmux robuster.

Ctrl+B d

abkoppeln (Sitzung läuft weiter)

Ctrl+B c

neues Fenster

Ctrl+B % / Ctrl+B "

links/rechts / oben/unten teilen

tmux ls

Sitzungen auflisten

tmux new -s deploy

tmux attach -t deploy

Installation über deinen Paketmanager. GNU screen ist die ältere Alternative (Ctrl+A d zum Abkoppeln, screen -r zum Wiederverbinden).

nice -n 19 tar -czf backup.tgz /data

sudo renice -n -5 -p 1234

Der Nice-Wert reicht von -20 (höchste Priorität) bis 19 (niedrigste). Nur root darf unter 0 gehen.

timeout 30s curl -s https://example.com/health

timeout -s KILL 5m ./job.sh

Endet mit Status 124, wenn das Zeitlimit erreicht wurde.

sudo fuser -vm /mnt/usb

sudo fuser -v 8080/tcp

Achtung: fuser -k beendet ohne Rückfrage jeden Prozess, der das Ziel nutzt; bei einem Mountpoint kann das auch deine eigene Shell sein.

-a

alles

-r

Kernel-Release

-m

Rechnerarchitektur: x86_64, aarch64

uname -r

uname -m

cat /etc/os-release

lsb_release -a

macOS/BSD: macOS: sw_vers.

uptime

Die Last ist die Zahl der laufenden oder wartenden Prozesse. Vergleich sie mit der CPU-Anzahl (nproc): Eine Last von 4 auf 4 Kernen bedeutet volle Auslastung.

free -h

macOS/BSD: macOS: vm_stat oder top -l 1 | grep PhysMem.

Linux nutzt freien RAM als Festplatten-Cache, daher sieht „free“ auf einem gesunden Rechner niedrig aus. „available“ ist das, was Programme noch bekommen können.

lscpu

make -j"$(nproc)"

macOS/BSD: macOS: sysctl -n hw.ncpu und sysctl -n machdep.cpu.brand_string.

-T

lesbare Zeitstempel

-w

neuen Meldungen folgen

--level=err,warn

nur Probleme

sudo dmesg -T | tail -30

sudo dmesg -T | grep -i 'out of memory'

vmstat 1 5

iostat -xz 1

iostat stammt aus dem Paket sysstat.

+%F

YYYY-MM-DD

+%s

Unix-Zeitstempel (Sekunden)

-d 'text'

ein Datum parsen: tomorrow, 2 days ago, @1700000000 (GNU)

-u

UTC

date '+%Y-%m-%d %H:%M:%S'

date +%s

date -d @1700000000

date -d '2 days ago' +%F

macOS/BSD: date unter macOS hat kein -d. Nimm date -r 1700000000 für einen Zeitstempel, date -v-2d für „vor 2 Tagen“ und date -j -f '%Y-%m-%d' 2026-10-18 +%s zum Parsen.

Zeitstempel mit dem Unix-Timestamp-Konverter umrechnen →

-h

lesbare Größen

-T

Dateisystemtyp anzeigen (GNU)

-i

Inode-Nutzung statt Bytes

df -h

df -h .

df -i

macOS/BSD: Unter macOS filtert -T nach Typ, statt ihn anzuzeigen.

-s

eine Summe pro Argument

-h

lesbare Größen

-d N

Tiefenlimit (GNU-Langform: --max-depth=N)

-x

auf einem Dateisystem bleiben

du -sh /var/log

du -h -d 1 | sort -h

sudo du -xh -d 1 / | sort -h | tail

macOS/BSD: du unter macOS hat -d, aber kein --max-depth.

sudo ncdu -x /

Installieren mit apt install ncdu / dnf install ncdu.

-f

Dateisystemtyp, Label, UUID, Mountpoint

lsblk

lsblk -f

macOS/BSD: macOS: diskutil list.

sudo umount /mnt/usb

sudo umount -l /mnt/nas

„target is busy“ heißt, dass ein Prozess sie nutzt (oft deine eigene Shell, die in dem Verzeichnis steht): Finde ihn mit fuser -vm oder lsof.

UUID=3f6c...  /data  ext4  defaults,nofail  0  2

sudo mount -a

Ein Tippfehler in der fstab kann den nächsten Bootvorgang im Notfallmodus enden lassen. Führ nach dem Bearbeiten immer sudo mount -a (oder findmnt --verify) aus.

sudo fdisk -l

sudo parted /dev/sdb print

Achtung: Das Schreiben einer Partitionstabelle (w in fdisk, mklabel in parted) macht vorhandene Daten auf dieser Platte unerreichbar. Prüf vorher den Gerätenamen mit lsblk; /dev/sda und /dev/sdb vertauschen sich leicht.

sudo mkfs.ext4 -L data /dev/sdb1

sudo mkfs.vfat -F 32 /dev/sdc1

Achtung: Löscht das Dateisystem auf dem Ziel sofort, ohne Rückfrage, wenn das Gerät nicht eingehängt ist. Prüf das Gerät mit lsblk -f; wer /dev/sda statt /dev/sda1 oder die falsche Platte formatiert, zerstört sie.

sudo fsck -f /dev/sdb1

Achtung: Führ fsck nie auf einem mit Schreibzugriff eingehängten Dateisystem aus: Es kann es beschädigen. Erst aushängen, oder beim Root-Dateisystem von einem Rettungsmedium booten.

if= / of=

Eingabe- / Ausgabedatei oder -gerät

bs=4M

Blockgröße; größer ist schneller

status=progress

kopierte Bytes anzeigen (GNU)

conv=fsync

vor dem Beenden auf das Gerät schreiben

sudo dd if=ubuntu.iso of=/dev/sdX bs=4M status=progress conv=fsync

dd if=/dev/zero of=test.img bs=1M count=100

Achtung: dd überschreibt das Ziel bei of= ohne Rückfrage. Vertauschst du if= und of= oder wählst das falsche /dev/sdX, wird diese Platte gelöscht. Prüf es direkt vor dem Ausführen mit lsblk.

macOS/BSD: macOS: Ziel ist /dev/rdiskN (aus diskutil list) nach diskutil unmountDisk, nimm bs=4m und drück Ctrl+T für den Fortschritt.

swapon --show

sudo fallocate -l 2G /swapfile && sudo chmod 600 /swapfile && sudo mkswap /swapfile && sudo swapon /swapfile

Unter Btrfs braucht eine Swap-Datei zusätzliche Schritte (btrfs filesystem mkswapfile bei aktuellen btrfs-progs).

shred -u -n 3 secrets.txt

Achtung: Unumkehrbar. Außerdem nicht zuverlässig auf SSDs, Journaling- oder Copy-on-Write-Dateisystemen (Btrfs, ZFS) oder bei Snapshots; echten Schutz bietet Vollverschlüsselung.

ip -br a

ip a show eth0

hostname -I

macOS/BSD: macOS: ifconfig oder ipconfig getifaddr en0.

ip ersetzt das alte ifconfig (net-tools), das viele Distributionen nicht mehr installieren.

Netzbereich mit dem Subnetzrechner ermitteln →

ip r

ip route get 1.1.1.1

sudo ip route add 10.20.0.0/16 via 192.168.1.1

CIDR-Bereiche mit dem Subnetzrechner prüfen →

ip link

sudo ip link set eth0 down && sudo ip link set eth0 up

Achtung: Deaktivierst du die Schnittstelle, über die du per SSH verbunden bist, bricht deine Sitzung ab.

-t / -u

TCP / UDP

-l

nur lauschende Sockets

-p

den Prozess anzeigen (sudo, um die anderer Benutzer zu sehen)

-n

numerische Ports, kein DNS

-s

zusammenfassende Zahlen

sudo ss -tulpn

ss -tn state established '( dport = :443 )'

ss -s

macOS/BSD: macOS: lsof -iTCP -sTCP:LISTEN -n -P oder netstat -an.

ss ersetzt netstat; netstat -tulpn funktioniert noch, wo net-tools installiert ist.

-I

nur Header (HEAD-Anfrage)

-L

Weiterleitungen folgen

-o file / -O

in eine Datei speichern / mit dem entfernten Namen speichern

-s / -S

still / aber Fehler trotzdem anzeigen

-f

bei HTTP 4xx/5xx fehlschlagen (Exit 22), statt die Fehlerseite auszugeben

-v

ausführlich: Anfrage- und Antwort-Header, TLS

curl -I https://example.com

curl -LO https://example.com/file.tar.gz

curl -s -o /dev/null -w '%{http_code}\n' https://example.com

curl -fsSL https://example.com/install.sh -o install.sh

Einen curl-Befehl in Python, JavaScript oder Go umwandeln →

-d data

Anfrage-Body; impliziert POST

--data-binary @file

eine Datei unverändert senden

-H header

einen Header hinzufügen

-X METHOD

PUT, PATCH, DELETE…

-u user:pass

Basic Auth

curl -H 'Content-Type: application/json' -d '{"name":"Ada"}' https://api.example.com/users

curl -H "Authorization: Bearer $TOKEN" https://api.example.com/me

curl -X DELETE https://api.example.com/users/42

Den zurückgegebenen Statuscode nachschlagen →

-c

abgebrochenen Download fortsetzen

-O file

speichern unter (-O- für stdout)

-q

still

-r -np

rekursiv, nie ins übergeordnete Verzeichnis aufsteigen

wget -c https://example.com/big.iso

wget -qO- https://example.com/data.json | jq .

macOS/BSD: Nicht im Standard-macOS; nimm curl -LO (curl -C - -LO zum Fortsetzen).

dig +short example.com

dig MX example.com

dig @1.1.1.1 example.com

dig -x 8.8.8.8

dig +trace example.com

Paketname: dnsutils (Debian/Ubuntu) oder bind-utils (Fedora/RHEL).

resolvectl status

sudo resolvectl flush-caches

macOS/BSD: macOS: sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder.

Nur auf Systemen mit systemd-resolved (standardmäßig Ubuntu, Fedora).

-c N

nach N Paketen aufhören

-i sec

Intervall zwischen Paketen

-4 / -6

IPv4 / IPv6 erzwingen

ping -c 4 example.com

Unter Linux und macOS läuft ping bis Ctrl+C, sofern du kein -c angibst (Windows hört nach 4 auf). Keine Antwort heißt nicht immer, dass er down ist: Viele Hosts blockieren ICMP.

traceroute -n example.com

tracepath example.com

macOS/BSD: macOS hat traceroute, aber kein tracepath.

traceroute muss unter Linux eventuell installiert werden; tracepath (iputils) ist meist vorhanden.

mtr -rw -c 100 example.com

Kombiniert ping und traceroute. Verlust nur an einem Hop in der Mitte liegt meist daran, dass dieser Router ICMP niedrig priorisiert; Verlust, der bis zum Ende anhält, ist echt.

-L 5432:localhost:5432

lokaler Port 5432 erreicht Port 5432 auf dem Server

-R 8080:localhost:3000

Server-Port 8080 erreicht deinen lokalen Port 3000

-D 1080

SOCKS-Proxy auf lokalem Port 1080

-N

kein entfernter Befehl, nur der Tunnel

ssh -N -L 5432:localhost:5432 alice@db-host

ssh -N -D 1080 alice@host

-r

Verzeichnisse kopieren

-P port

Port (großes P; ssh nutzt kleines -p)

-i key

Schlüsseldatei

scp report.pdf alice@host:/tmp/

scp alice@host:/var/log/app.log .

scp -r -P 2222 site/ alice@host:~/

Seit OpenSSH 9.0 nutzt scp darunter das SFTP-Protokoll. Bei großen oder wiederholten Kopien ist rsync schneller, weil es nur Änderungen überträgt.

-a

Archiv: rekursiv, behält Berechtigungen, Zeiten, Links

-v

ausführlich

-z

bei der Übertragung komprimieren

-P

Fortschritt und Fortsetzen abgebrochener Dateien

-n

Probelauf: zeigen, was passieren würde

--exclude 'pattern'

Dateien überspringen

-e 'ssh -p 2222'

eigene SSH-Optionen

rsync -avzP site/ deploy@host:/srv/site/

rsync -av --exclude 'node_modules' ./ /backup/app/

macOS/BSD: Neuere macOS-Versionen liefern openrsync statt rsync aus; gängige Flags funktionieren, manche seltenere nicht.

src/ bedeutet „der Inhalt von src“; src ohne Schrägstrich bedeutet „der Ordner src“. Wer das verwechselt, verschachtelt Ordner (dest/src/…).

rsync -avn --delete site/ /srv/site/

rsync -av --delete site/ /srv/site/

Achtung: Löscht alles im Ziel, was nicht in der Quelle ist. Vertauschte Quelle und Ziel oder ein leerer/falscher Quellpfad leeren das Ziel. Immer zuerst mit -n ausführen.

nc -zv db.internal 5432

nc -l 9000

Die Flags unterscheiden sich zwischen netcat-Varianten: Die traditionelle braucht nc -l -p 9000.

sudo ufw status verbose

sudo ufw allow 22/tcp

sudo ufw allow from 10.0.0.0/8 to any port 5432

Achtung: sudo ufw enable auf einem entfernten Server, ohne vorher SSH zu erlauben (ufw allow OpenSSH oder 22/tcp), sperrt dich aus.

sudo firewall-cmd --list-all

sudo firewall-cmd --permanent --add-service=https && sudo firewall-cmd --reload

sudo firewall-cmd --permanent --add-port=8080/tcp

Ohne --permanent gilt eine Regel nur bis zum nächsten Reload oder Neustart.

-m

Home-Verzeichnis anlegen (nicht auf jeder Distribution Standard)

-s /bin/bash

Login-Shell

-G group1,group2

zusätzliche Gruppen

sudo useradd -m -s /bin/bash alice && sudo passwd alice

Unter Debian/Ubuntu ist adduser alice der freundlichere interaktive Wrapper, der Home-Verzeichnis und Passwort einrichtet.

sudo usermod -aG docker alice

sudo usermod -aG sudo alice

Achtung: Ohne -a ersetzt usermod -G alle zusätzlichen Gruppen des Benutzers, was den sudo-Zugriff entfernen kann. Gruppenänderungen greifen bei der nächsten Anmeldung (oder führ newgrp docker aus).

sudo userdel -r olduser

Achtung: -r löscht das Home-Verzeichnis samt Dateien endgültig. Sichere es vorher oder sperre stattdessen das Konto (passwd -l).

sudo visudo -f /etc/sudoers.d/deploy

deploy ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart myapp

visudo prüft die Syntax vor dem Speichern. Wer /etc/sudoers mit einem normalen Editor bearbeitet und sich vertippt, kann alle von sudo aussperren.

-c

erstellen

-z / -j / -J

Komprimierung mit gzip / bzip2 / xz

-f file

Name der Archivdatei (direkt nach f angeben)

-v

Dateien beim Hinzufügen auflisten

--exclude='pattern'

Dateien auslassen

tar -czf site-2026-10-18.tar.gz site/

tar -cJf logs.tar.xz --exclude='*.tmp' logs/

-x

entpacken

-C dir

nach dir entpacken (muss existieren)

--strip-components=1

den obersten Ordner weglassen

tar -xf archive.tar.gz

tar -xzf app.tar.gz -C /opt/app --strip-components=1

tar --zstd -cf data.tar.zst data/

zstd -d file.zst

Braucht GNU tar 1.31+ (oder ein aktuelles bsdtar) und das Programm zstd.

-k

Original behalten

-d

entpacken (wie gunzip)

-9

beste Komprimierung

gzip -k access.log

zcat access.log.gz | grep 404

zgrep 500 access.log.*.gz

Ohne -k ersetzt gzip die Datei durch die .gz-Version.

zip -r site.zip site/

zip -r site.zip site/ -x '*.git*' '*/node_modules/*'

zip -e verschlüsselt mit dem veralteten ZipCrypto-Verfahren, das schwach ist. Für echte Geheimhaltung nimm 7z oder gpg.

7z x archive.7z

7z a -p backup.7z docs/

7z l archive.rar

Paket: p7zip-full / 7zip unter Debian/Ubuntu, p7zip oder 7zip unter Fedora/Arch.

sha256sum ubuntu.iso

sha256sum -c SHA256SUMS --ignore-missing

macOS/BSD: macOS: shasum -a 256 file (und shasum -a 256 -c SUMSFILE).

Text oder eine Datei im Browser hashen →

-name

Glob, Groß-/Kleinschreibung beachtet

-iname

ohne Beachtung von Groß-/Kleinschreibung

-path

gegen den ganzen Pfad prüfen

find . -name '*.log'

find / -iname 'nginx.conf' 2>/dev/null

-mtime -1

in den letzten 24 Stunden geändert

-mtime +30

vor mehr als 30 Tagen

-mmin -60

in den letzten 60 Minuten

-newer ref

neuer als die Datei ref

find /var/log -type f -mtime +30

find . -type f -mmin -15

find /tmp/app -name '*.tmp' -mtime +7 -print

find /tmp/app -name '*.tmp' -mtime +7 -delete

Achtung: Die Reihenfolge zählt: -delete wirkt dort, wo es steht, also löscht find . -delete -name "*.tmp" alles unter ., bevor der Namenstest überhaupt greift. Setz -delete ans Ende und führ zuerst -print aus.

locate -i nginx.conf

sudo updatedb

Bereitgestellt von plocate oder mlocate; der Index wird täglich neu erstellt, heute angelegte Dateien fehlen also eventuell, bis updatedb läuft.

-i

Groß-/Kleinschreibung ignorieren

-n

Zeilennummern anzeigen

-v

umkehren: Zeilen, die nicht passen

-w

nur ganze Wörter

-c

passende Zeilen zählen

-o

nur den passenden Teil ausgeben

-F

fester String, kein regulärer Ausdruck

grep -n 'ERROR' app.log

grep -v '^#' nginx.conf | grep -v '^$'

grep -c 'Failed password' /var/log/auth.log

-r

rekursiv

-l

nur Dateinamen

--include='*.py'

nur diese Dateien

--exclude-dir=node_modules

Ordner überspringen

grep -rn 'TODO' src/

grep -rl --include='*.php' 'mysql_connect' .

grep -rn --exclude-dir={.git,node_modules} 'apiKey' .

grep -E 'error|warn' app.log

grep -Eo '[0-9]{1,3}(\.[0-9]{1,3}){3}' access.log | sort | uniq -c | sort -rn | head

grep -P '\d{4}-\d{2}-\d{2}' file

macOS/BSD: -E funktioniert überall; -P (PCRE) ist eine GNU-Funktion und nicht in jeder macOS-Version verfügbar.

Das Muster im Regex-Tester ausprobieren →

g

jeden Treffer in der Zeile ersetzen, nicht nur den ersten

-E

erweiterter regulärer Ausdruck (Gruppen ohne Backslashes)

I

ohne Beachtung von Groß-/Kleinschreibung (GNU)

sed 's/http:/https:/g' links.txt

sed 's|/usr/local|/opt|g' paths.txt

sed -E 's/([0-9]+)px/\1rem/g' style.css

sed -i 's/^#Port 22/Port 2222/' /etc/ssh/sshd_config

sed -i.bak 's/foo/bar/g' config.ini

macOS/BSD: sed unter macOS verlangt ein Argument nach -i: sed -i '' 's/foo/bar/g' file. GNU sed liest '' als Skript, die einzige Form, die in beiden funktioniert, ist also -i.bak.

-F sep

Feldtrenner (Standard: Folgen von Leerzeichen/Tabs)

$1 … $NF

Felder; $NF ist das letzte, $0 die ganze Zeile

NR

Zeilennummer

awk '{print $1}' access.log

awk -F: '{print $1, $7}' /etc/passwd

awk -F, 'NR>1 {print $2}' data.csv

cut -d, -f1,3 data.csv

cut -d: -f1 /etc/passwd

cut -c1-10 file

cut behandelt jedes Trennzeichen als Feldgrenze, zwei Leerzeichen ergeben also ein leeres Feld. Für mit Leerzeichen ausgerichtete Ausgabe nimm awk.

-n

numerisch

-r

umgekehrt

-h

lesbare Größen: 2K < 1M < 3G

-k 2,2

nur nach Feld 2 sortieren

-t ,

Feldtrenner

-u

Duplikate entfernen

-V

Versionsreihenfolge: 1.9 < 1.10

du -sh * | sort -h

sort -t, -k3,3nr data.csv

sort -u emails.txt > unique.txt

-c

jeder Zeile ihre Anzahl voranstellen

-d

nur Zeilen, die sich wiederholen

-u

nur Zeilen, die einmal vorkommen

sort ips.txt | uniq -c | sort -rn | head

uniq fasst nur aufeinanderfolgende Duplikate zusammen, also vorher sortieren.

wc -l access.log

ls | wc -l

grep -c '' file

Wörter und Zeichen im Browser zählen →

tr 'a-z' 'A-Z' < in.txt

tr -d '\r' < windows.txt > unix.txt

tr -s ' ' < file

tr '\n' ',' < list.txt

tr liest nur die Standardeingabe, leite die Datei also mit < hinein.

-0

Eingabe ist NUL-getrennt (mit find -print0 kombinieren); sicher bei Leerzeichen

-n N

höchstens N Argumente pro Befehl

-P N

N Befehle parallel ausführen

-I {}

{} durch jede Eingabezeile ersetzen

-r

Befehl nicht ausführen, wenn die Eingabe leer ist (GNU)

find . -name '*.log' -print0 | xargs -0 rm -f

cat urls.txt | xargs -n 1 -P 4 curl -sO

ls *.png | xargs -I {} cp {} /backup/{}

macOS/BSD: GNU xargs führt den Befehl auch bei leerer Eingabe einmal aus, außer du gibst -r an; xargs unter macOS überspringt leere Eingaben standardmäßig und akzeptiert -r aus Kompatibilitätsgründen.

.

schön formatiert ausgeben

-r

rohe Strings, ohne Anführungszeichen

-c

kompakt, eine Zeile pro Ergebnis

.[]

über ein Array iterieren

select(cond)

passende Elemente behalten

jq . response.json

jq -r '.items[].name' data.json

jq -r '.[] | select(.active) | .email' users.json

curl -s https://api.github.com/repos/jqlang/jq | jq '.stargazers_count'

Installieren mit apt/dnf install jq. Bei aktuellem macOS dabei.

JSON im Browser formatieren und validieren →

printf '%s' 'user:pass' | base64

echo dXNlcjpwYXNz | base64 -d

base64 -w 0 image.png > image.b64

macOS/BSD: base64 unter macOS bricht standardmäßig nicht um und hat kein -w. Zum Dekodieren -d verwenden (ältere macOS-Versionen nutzten -D).

Base64 im Browser kodieren oder dekodieren →

sudo systemctl restart nginx

sudo systemctl reload nginx

Teste die Konfiguration nach Möglichkeit vor dem Neustart, z. B. mit sudo nginx -t, damit ein Tippfehler die Website nicht lahmlegt.

-u unit

ein Dienst

-f

folgen

-n N

letzte N Zeilen

--since '1 hour ago'

auch: today, yesterday, 2026-10-18 09:00

-p err

Priorität err und schlimmer

-b / -b -1

dieser Bootvorgang / vorheriger Bootvorgang

-e

ans Ende springen

journalctl -u nginx -f

journalctl -u myapp --since '10 min ago'

journalctl -b -1 -p err

journalctl --disk-usage

sudo journalctl --vacuum-size=500M

sudo journalctl --vacuum-time=14d

Für ein dauerhaftes Limit SystemMaxUse= in /etc/systemd/journald.conf setzen.

sudo tail -f /var/log/syslog

sudo tail -f /var/log/auth.log

Manche Distributionen (Fedora, Arch) speichern Logs nur im Journal, sofern rsyslog nicht installiert ist.

crontab -e

crontab -l

crontab -l > crontab.bak

Den Zeitplan im Cron-Generator erstellen und erklären lassen →

30 2 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1

*/15 * * * * /usr/local/bin/check.sh

0 9 * * 1-5 /usr/local/bin/report.sh

@reboot /usr/local/bin/startup.sh

Cron läuft mit minimalem PATH und ohne Shell-Profil: Nutze absolute Pfade. Ein % im Befehl muss als \% escapt werden.

Prüfen, was ein Cron-Ausdruck bedeutet →

crontab -l > ~/crontab.bak && crontab -r

crontab ~/crontab.bak

Achtung: Löscht ohne Rückfrage alle deine Cron-Jobs, und r liegt auf der Tastatur direkt neben e. Manche Cron-Implementierungen bieten -i, um vorher zu fragen (crontab -ri).

0 3 * * * root /usr/local/bin/cleanup.sh

ls /etc/cron.daily/

Unter Debian und Ubuntu werden Dateien in /etc/cron.d ignoriert, deren Namen einen Punkt enthalten; nenn sie also backup, nicht backup.cron.

echo 'systemctl restart myapp' | sudo at 02:00

echo './report.sh' | at now + 30 minutes

atq

atrm 3

Braucht das Paket at und einen laufenden atd-Dienst.

ls -l > listing.txt

echo 'done' >> progress.log

set -o noclobber

Die Shell leert die Datei, bevor der Befehl läuft, daher bleibt bei sort file > file eine leere Datei übrig. Schreib in einen neuen Namen und dann mv.

echo "Today is $(date +%A)"

echo $(( 1024 * 4 ))

diff <(ls dir1) <(ls dir2)

Backticks `command` sind die alte Form von $(command); $( ) lässt sich verschachteln und liest sich besser.

ls *.jpg

rm photo-??.png

cp config.{yml,yml.bak}

shopt -s globstar; ls **/*.md

Globs erfassen standardmäßig keine Punktdateien (shopt -s dotglob ändert das). Passt nichts, übergibt bash das Muster wörtlich, außer shopt -s nullglob ist gesetzt.

export NODE_ENV=production

DEBUG=1 ./app

printenv | sort

unset DEBUG

Gehen verloren, wenn die Shell beendet wird. Leg exports in ~/.bashrc (interaktive Shells) oder ~/.profile (Login-Shells) ab, damit sie bleiben.

sudo !!

cd !$

!42

^foo^bar

Mit HISTCONTROL=ignorespace (unter Ubuntu als Teil von ignoreboth Standard) wird ein Befehl mit führendem Leerzeichen nicht gespeichert: nützlich für Befehle mit Geheimnissen.

Ctrl+R

Verlauf rückwärts durchsuchen; erneut drücken für ältere Treffer

Ctrl+A / Ctrl+E

Zeilenanfang / Zeilenende

Ctrl+U / Ctrl+K

bis zum Zeilenanfang / Zeilenende ausschneiden

Ctrl+W

das vorherige Wort ausschneiden

Ctrl+Y

Ausgeschnittenes einfügen

Alt+B / Alt+F

ein Wort zurück / vor

Alt+.

das letzte Argument des vorherigen Befehls einfügen

Ctrl+L

Bildschirm leeren

Ctrl+C

laufenden Befehl abbrechen

Ctrl+D

Ende der Eingabe; beendet die Shell bei leerer Zeile

Tab Tab

Vervollständigungen anzeigen

bind -P | less

Spickzettel für Mac-Tastenkombinationen →

#!/usr/bin/env bash
set -euo pipefail
name="${1:-world}"
if [[ -f "$name.txt" ]]; then
  echo "found $name.txt"
fi
for f in *.log; do
  echo "$f"
done

chmod +x script.sh && ./script.sh Ada

bash -x script.sh

$1 … $9 sind Argumente, "$@" sind alle, $# ist ihre Anzahl. [[ ]] ist bash; in POSIX-sh-Skripten [ ] verwenden.

Bash-Schleifen und -Bedingungen neben CMD und PowerShell →