Einleitung

Willkommen zur macOS Terminal Referenz

Das Terminal ist weit mehr als ein schwarzes Fenster mit grünem Text – es ist das mächtigste Werkzeug auf deinem Mac. Während die grafische Oberfläche ihre Berechtigung hat, ermöglicht das Terminal eine Kontrolle und Effizienz, die mit Mausklicks unerreichbar bleibt.

Warum das Terminal beherrschen?

Das macOS-Terminal bzw. die Shell (standardmäßig zsh seit macOS Catalina) ist die direkte und mächtigste Schnittstelle zum Betriebssystem. Es ermöglicht:

• Geschwindigkeit: Navigation mit der Tastatur – keine Mausklicks, keine Verzögerungen
• Automatisierung: Komplexe Aufgaben mit einem einzigen Befehl wiederholen
• Kontrolle: Zugriff auf (versteckte) Systemeinstellungen und Systemdateien
• Entwicklung: Konfiguration von Entwicklungsumgebungen, Verwaltung von Git-Repositories, Deployment von Code
• Fehleranalyse: Durchsuchen von Logs, Analysieren von Prozesse, Verstehen von Systeminformationen
• Server-Verwaltung: Effiziente Verwaltung von Cloud-Systemen und Remote-Servern

Inhalte

Diese Referenz ist in vier Teile gegliedert:

Teil I: Grundlagen

Essentiellen Befehle, Verständnis für das Dateisystem, Konfiguration der Shell, eine Basis für effizientes Arbeiten im Terminal legen

Teil II: Fortgeschrittene Themen

Von Shell-Scripting über tmux bis zu ZLE-Widgets – hier wird tiefer eingetaucht und erklärt, wie du das Terminal zum persönlichen Produktivitäts-Multiplikator wird.

Teil III: Cheat Sheets

Schnellreferenzen für häufig verwendete Tools und Programmiersprachen – immer griffbereit.

Teil IV: Terminals, Shells und Erweiterungen

Moderne Terminal-Emulatoren, Shell-Erweiterungen und die neuesten CLI-Tools, welche die Arbeit noch angenehmer machen.

Wie diese Referenz genutzt werden kann

Diese Referenz ist als Nachschlagewerk konzipiert. Man muss sie nicht von vorne bis hinten durcharbeiten:

• Als Anfänger: Start mit Teil I und sequentielles Durcharbeiten der Grundlagen
• Als Fortgeschrittener: Direkt zu den Themen, die einen interessieren
• Im Alltag: Nutzung der Suchfunktion und Cheat Sheets als schnelle Referenz

Jedes Kapitel enthält praktische Beispiele, die man direkt in deinem Terminal ausprobieren kann.

Terminal und Dateisystem

1 Was ist das Terminal

Das Terminal ist ein Programm, dass eine Shell, d. h. einen Kommandozeileninterpreter, ausführt. macOS nutzt standardmäßig zsh (Z Shell). Es wird im folgenden davon ausgegangen, dass zsh verwendet wird.

Welche Shell genutzt wird, kann man dem folgenden Befehl geprüft werden:

echo $SHELL

2 Wichtige Konzepte/Begriffe

3 Dateisystem von macOS

3.1 Aktuelles Dateisystem: APFS (Apple File System)

Seit macOS 10.13 (High Sierra, 2017) ist APFS das Standard-Dateisystem für SSDs; seit macOS 10.15 (Catalina, 2019) auch für alle Laufwerke.

Merkmale:

• Copy-on-Write (CoW): Änderungen an Dateien oder Metadaten erzeugen neue Kopien, was das System sicherer macht.

  (Änderungen werden nicht direkt auf bestehende Daten geschrieben werden. Stattdessen legt das System beim Ändern von Dateien oder Metadaten eine neue Kopie der betroffenen Blöcke an und verweist erst danach auf sie. Dadurch bleiben alte Datenversionen solange erhalten, bis der Schreibvorgang erfolgreich abgeschlossen ist. Das schützt vor Datenverlust bei Stromausfall oder Absturz. Außerdem ermöglicht CoW Systemfunktionen wie Snapshots, bei denen ganze Dateisystemzustände nahezu ohne Speicheraufwand gespeichert werden.)

• Snapshots: Das System kann zu bestimmten Zeitpunkten eingefroren werden (z. B. vor Systemupdates). Dadurch kann bei Problemen auf einen alten Zustand zurückgewechselt werden. Time Machine nutzt diese Funktion.

• Space Sharing: Mehrere Volumes (z. B. “Macintosh HD” und “Macintosh HD – Data”) teilen sich denselben physischen Speicherplatz. Das spart Platz, da ungenutzter Speicher flexibel zwischen Volumes verteilt wird.

• Verschlüsselung: Native Unterstützung für FileVault 2 und einzelne verschlüsselte Volumes. (FileVault 2 verschlüsselt das gesamte Systemvolume, schützt Daten bei Diebstahl und sorgt dafür, dass nur berechtigte Benutzer darauf zugreifen können.)

• Case Sensitivity: Standardmäßig nicht case-sensitive (d. h. Datei.txt = datei.txt), kann aber beim Formatieren geändert werden.

3.2 Wichtige Volumes und Partitionen

Seit macOS Catalina ist das System in mehrere logische Volumes aufgeteilt:

• Macintosh HD: Systemvolume (read-only, geschützt durch SIP) (Das Systemvolume enthält das schreibgeschützte Betriebssystem inklusive aller Kernkomponenten, Frameworks und Standardprogramme.)

• Macintosh HD – Data: Benutzer- und Programmdaten (beschreibbar) persönliche Dateien, Dokumente, Einstellungen und installierte Programme, z. B. in /Users/<username> oder /Applications.

• Preboot, Recovery, VM: Hilfsvolumes für Boot, Wiederherstellung und Swap Preboot hilft beim Starten des Systems, Recovery ermöglicht Wiederherstellung und VM speichert Swap- bzw. Auslagerungsdateien temporär.

Mit dem Befehl diskutil wird die komplette Volume-Struktur angezeigt.

3.3 Systemschutz und Berechtigungen

macOS schützt kritische Systembereiche durch verschiedene Mechanismen, damit Systemdateien nicht versehentlich verändert werden können.

• SIP (System Integrity Protection): Schützt Systemverzeichnisse und Kernel-Extensions. Nur im Recovery-Modus deaktivierbar.

• Sandboxing: Viele Apps laufen in isolierten Containern, sodass sie nur auf erlaubte Dateien zugreifen können. Dies begrenzt Schäden durch fehlerhafte oder schadhafte Programme.

• ACLs & POSIX Permissions: macOS verwendet klassische Unix-Rechte (rwx, siehe ../SUMMARY) und erweiterte Access Control Lists (siehe ../SUMMARY). → Anzeigen mit ls -le.

3.4 Mountpoints und Pfade

• Alle Volumes werden unter /Volumes/ eingehängt.
• Netzlaufwerke oder externe Festplatten erscheinen dort automatisch.
• Systempfade wie /System, /Library oder /usr sind meist Symlinks auf interne Strukturen des schreibgeschützten Systemvolumes.

4 Ordnerstruktur und wichtige Verzeichnisse

macOS basiert auf UNIX (BSD), daher folgt es grob der klassischen Unix-Hierarchie – erweitert um Apple-spezifische Pfade.

4.1 Systemebene (Root /)

4.2 Benutzerverzeichnisse (/Users)

Jeder Benutzer hat ein eigenes Homeverzeichnis, z. B. /Users/john.

Wichtige Unterordner:

chflags nohidden ~/Library

4.3 Weitere wichtige Orte

5 macOS unter der Haube

macOS basiert auf UNIX/BSD und Darwin. Unter der Haube steuern Launchd, Logging und Sicherheitsmechanismen, wie Gatekeeper oder TCC, den Systembetrieb.

5.1 Launchd und Dienste

launchd ist das zentrale Init-System von macOS und ersetzt klassische Systeme wie systemd oder init. Es startet Prozesse beim Booten, nach Bedarf oder im Benutzerkontext. Dienste werden über Property-List-Dateien (.plist) definiert.

Speicherort der .plist-Dateien:

• /System/Library/LaunchDaemons,
• /Library/LaunchAgents oder
• ~/Library/LaunchAgents

Aktive Dienste anzeigen:

launchctl list

Manuelle Steuerung von Diensten:

launchctl load/unload

Damit verwaltet macOS sowohl System- als auch Benutzerprozesse konsistent.

5.2 Systemprotokolle und Logging

macOS verwendet seit Sierra ein Unified Logging System, das alle Logmeldungen zentral verfügbar macht.

Vergangene Ereignisse anzeigen:

log show

Live Ansicht von Ereignissen:

log stream

Diese Logs sind strukturiert und nach Subsystemen gegliedert, z. B. “network”, “kernel” oder “security”.

Ältere Textlogs existieren weiterhin unter /var/log/, z. B. system.log. Entwickler oder Administratoren können mit Filtern wie

log show --predicate 'eventMessage contains "error"'

gezielt Fehlermeldungen finden.

5.3 Netzwerk & Namensauflösung

macOS bietet zahlreiche Kommandozeilenwerkzeuge zur Verwaltung und Diagnose von Netzwerken. Neben klassischen UNIX-Befehlen wie ping und traceroute sind vor allem networksetup und scutil für Systemkonfigurationen relevant.

Über den Dienst mDNSResponder (Bonjour) werden Geräte im lokalen Netz automatisch erkannt. Die Datei /etc/hosts erlaubt lokale DNS-Zuordnungen.

5.4 Sicherheitsmechanismen

Die folgenden Mechanismen/Schutzebenen wirken zusammen, um das System vor Malware und unautorisierten Änderungen zu schützen:

• Gatekeeper blockiert unsignierte oder nicht-notarisierte Apps.
• SIP (System Integrity Protection) schützt Systemverzeichnisse und Kernel-Komponenten selbst vor Root-Änderungen.
• Notarization stellt sicher, dass Apps von Apple geprüft wurden.
• Sandboxing und TCC (Transparency, Consent & Control) begrenzen App-Zugriffe auf Dateien, Kamera, Mikrofon usw.

5.5 Prozess- & Systemüberwachung

Es gibt mehrere Tools, um Prozesse, Ressourcen und Systemzustände zu überwachen. Während ps und top Standardbefehle aus der UNIX-Welt sind, liefert htop eine moderne, farbige Ansicht. Befehle wie lsof, vm_stat und powermetrics helfen bei tiefergehender Analyse von Performance, Speicher oder Energieverbrauch.

Die wichtigsten Befehle

1 Navigation

1.1 ls-Befehl

ls -l    # Detaillierte Liste mit Berechtigungen, Datum, Größe, ...
ls -a    # Zeigt auch versteckte Dateien und Ordner an
ls -la   # Kombination: Detaillierte Liste inkl. versteckter Elemente
ls -lh   # Liste mit Größenangaben in passender Einheit (KB, MB, GB)
ls -lah  # Kombination
ls -lt   # Sortierung nach Änderungsdatum
ls -lS   # Sortierung nach Dateigröße
ls -l <pfad>  # Anzeigen von Dateien/Ordner des gegebenen Pfads

1.2 cd-Befehl

cd Documents    # Wechselt in den Unterordner Documents
cd ~/Downloads  # Wechselt in den Ordner Downloads im Homeverzeichnis
cd /      # Wechselt in Hauptverzeichnis
cd ~      # Wechselt in das Homeverzeichnis
cd ..     # Wechselt ins Eltern-Verzeichnis
cd ../..  # Geht zwei Ebenen nach oben
cd -      # Springt zum letzten Verzeichnis zurück

Siehe auch: ~ vs. $HOME

1.3 history-Befehl

history               # Zeigt die letzten ausgeführten Befehle an
history | grep "cal"  # Zeigt die letzten Befehle an, passen zum Suchbegriff
!123                  # Führt Befehl 123 erneut aus
!!                    # Führt den letzten Befehl erneut aus

2 Dateien und Ordner

>rm -i test.txt
>```

</div>


<div class="mdbook-callouts mdbook-callouts-tip">
<p class="mdbook-callouts-title">
  <span class="mdbook-callouts-icon"></span>
  tip
</p>


Bevor mehrere Dateien gelöscht werden, sollen die Auswirkungen des zugehörigen Befehls geprüft werden. Beispiel:

```zsh
ls *.py
rm *.py

2.1 mkdir-Befehl

mkdir NeuerOrdner          # Erstellt einen Ordner
mkdir Ordner1 Ordner2      # Erstellt mehrere Ordner
mkdir -p Fotos/2025/10/29  # Erstellt Ordner + Unterordner

Brace Expansion für effiziente Stapelerstellung:

Geschweifte Klammern ermöglichen die schnelle Erstellung mehrerer ähnlicher Elemente:

mkdir Tag_{01..03}           # Erstellt: Tag_01, Tag_02, Tag_03
mkdir {Januar,Februar,März}  # Erstellt drei Monatsordner
touch datei_{a,b,c}.txt      # Erstellt: datei_a.txt, datei_b.txt, datei_c.txt
echo {01..05}                # Zeigt: 01 02 03 04 05
cp dokument.txt{,.backup}    # Kopiert nach dokument.txt.backup

Kombinationen sind ebenfalls möglich:

mkdir -p Projekt/{src,tests,docs}/{python,rust}
# Erstellt: Projekt/src/python, Projekt/src/rust,
#           Projekt/tests/python, Projekt/tests/rust,
#           Projekt/docs/python, Projekt/docs/rust

2.2 cp- und mv-Befehl

cp quelle.txt ziel.txt     # Kopiert eine Datei
cp -i quelle.txt ziel.txt  # Fragt nach bevor überschrieben wird
cp -r Ordner1 Ordner2      # Kopiert einen kompletten Ordner (rekursiv)
cp *.txt Text              # Kopiert alle Dateien mit der Endung .txt

Gleiche Syntax beim mv-Befehl.

3 Arbeiten mit Texten und Dateien

Alternative zu less datei.txt: cat datei.txt | more

3.1 Navigation bei Anzeige über less-Befehl

• Leertaste: Nächste Seite
• b: Vorherige Seite
• /: Vorwärts suchen
• ?: Rückwärts suchen
• q: Beenden

3.2 head- und tail-Befehl

head datei.txt        # Zeigt die ersten 20 Zeilen
head -n 20 datei.txt  # Zeigt die ersten 20 Zeilen
tail datei.txt        # Zeigt die letzten 10 Zeilen
tail -n 20 datei.txt  # Zeigt die letzten 20 Zeilen

3.3 Dateiinhalt in Echtzeit anzeigen

Änderungen in Echtzeit können mit folgendem Befehl verfolgt werden:

tail -f info.log

Dies funktioniert jedoch nicht immer. Viele Editoren speichern Änderungen nicht direkt in der bestehenden Datei, sondern erstellen eine temporäre Datei, schreiben den neuen Inhalt hinein, löschen die alte Datei und benennen die neue Datei auf den alten Namen um. Dabei ändert sich die inode (Datei-Identität im Dateisystem). Abhilfe schafft -F (follow name). Es wird erkannt, wenn die Datei ersetzt wurde und folgt automatisch der neuen Datei.

tail -F info.log

Hierbei wird jedoch immer der neue Dateiinhalt unter den alten geschrieben. Dies wird schnell unübersichtlich. Eine bessere Lösung ist mit dem Befehl watch möglich. Diese muss ggf. noch installiert werden:

brew install watch

Anschließend kann der Dateiinhalt wie folgt überwacht werden:

watch -n 1 "clear && cat info.log"

• -n 1: alle 1 Sekunden aktualisieren
• clear: Ausgabe löschen
• cat test.txt: Dateiinhalt anzeigen

Nutzt man dies öfters, empfiehlt sich die Erstellung eines Alias:

alias watchfile='watch -n 1 "clear && cat $1"'

Verwendung mit:

watchfile info.log

3.4 find-Befehl

find . -name "*.txt"          # Findet alle .txt-Dateien
find . -name "rechnung.pdf"   # Findet die Datei rechnung.pdf
find . -type f -size +5M      # Findet Dateien größer als 5 MB
find . -name "*.*" -mtime -7  # Dateien, die in den letzten 7 Tagen verändert wurden
find . -empty                 # Findet leere Dateien und Ordner

3.5 grep-Befehl

grep "Januar" notiz.txt     # Sucht in einer Datei
grep -r "Januar" notiz.txt  # Sucht rekursiv in einem Ordner
grep -n "Januar" notiz.txt  # Zeigt alle Zeilen inkl. Nr. mit dem Suchwort
grep -c "Januar" notiz.txt  # Zählt die Anzahl der Vorkommen des Suchworts
grep -i "Januar" notiz.txt  # Berücksichtigt Groß- und Kleinschreibung

3.6 Prozesse, Systeme und Netzwerk

3.7 Prozesse

3.8 top-Befehl

Kurzbefehle:

• o: Nach anderer Spalte sortieren (o drücken und Spaltenname eingeben)
• q: Beenden

Alternative: htop

htop liefert eine interaktive Anzeige in Farbe.

Installation:

brew install htop

3.9 ps-Befehl

ps                    # Zeigt die eigenen Prozesse
ps aux                # Zeigt alle Prozesse mit Details
ps aux | grep Safari  # Zeigt bestimmte Prozesse

3.10 System und Hardware

3.11 du-Befehl

du -sh * | sort -h   # Größe von Ordnern und Dateien aufsteigend sortiert
du -sh * | sort -hr  # Absteigend sortiert
du -sh * | sort -hr | head -5  # Beschränkung auf die 5 größten Elemente

3.12 uname-Befehl

uname     # Zeigt den Kernelnamen an (i. d. R. "Darwin")
uname -a  # Alle verfügbaren Systeminformationen
uname -s  # Gleiche ausgabe wie bei uname
uname -r  # Kernel-Version
uname -v  # Kernel-Buildversion
uname -m  # Machine hardware name
uname -n  # Rechnername (Hostname)
uname -p  # Prozessortyp (machmal leer)
uname -o  # Betriebssystem

3.13 date-Befehl

date              # Zeigt Datum+Zeit; z. B.: Thu Oct 30 21:53:42 CET 2025
date "+%Y-%m-%d"  # Zeigt Datum, z. B.: 2025-10-30
date "+%H:%M:%S"  # Zeigt Uhrzeit, z. B.: 21:53:42

3.14 cal-Befehl

cal          # Aktueller Monat
cal 2026     # Bestimmtes Jahr
cal 01 2026  # Bestimmter Monat

Beispielausgabe:

    January 2026
Su Mo Tu We Th Fr Sa
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

3.15 Netzwerk

Lokale IP-Adresse(n) anzeigen:

ifconfig | grep "inet "

3.16 curl-Befehl

curl ist ein vielseitiges Tool zum Abrufen oder Senden von Daten über HTTP, HTTPS, FTP und viele andere Protokolle. Es eignet sich sowohl zum einfachen Testen von Webseiten als auch für API-Aufrufe.

Beispiele:

# Webseite abrufen und im Terminal anzeigen
curl https://example.com

# Datei herunterladen
curl -O https://example.com/datei.zip

# API-Aufruf mit Header
curl -H "Authorization: Bearer TOKEN" https://api.example.com/data

Häufig verwendete Optionen:

• -I: nur Header anzeigen
• -L: Redirects folgen
• -d: POST-Daten senden

4 Job-Control (fg, bg, jobs, &)

Job-Control ermöglicht die Verwaltung von Prozessen, die im Hintergrund oder Vordergrund laufen. Dies ist besonders nützlich bei langläufigen Aufgaben oder wenn man mehrere Programme parallel ausführen möchte.

4.1 Grundlegende Konzepte

• Vordergrundprozess (Foreground): Prozess, der gerade aktiv ist und das Terminal blockiert

• Hintergrundprozess (Background): Prozess, der im Hintergrund läuft, während das Terminal weiter nutzbar bleibt

• Job: Eine vom Terminal gestartete Aufgabe (kann mehrere Prozesse enthalten)

4.2 Befehle

4.3 Beispiele

Prozess im Hintergrund starten:

python script.py &

Das & am Ende startet den Befehl sofort im Hintergrund. Das Terminal bleibt nutzbar.

Laufenden Prozess anhalten und in Hintergrund verschieben:

python script.py
# STRG + Z drücken (Prozess wird angehalten)
bg

Alle Jobs anzeigen:

jobs

Beispielausgabe:

[1]  + running    python script.py
[2]  - suspended  vim dokument.txt

Bestimmten Job in den Vordergrund holen:

fg %1    # Job 1 in den Vordergrund
fg %2    # Job 2 in den Vordergrund
fg       # Letzten Job in den Vordergrund

Hintergrundprozess beenden:

kill %1  # Beendet Job 1

4.4 Praktische Anwendungsfälle

Mehrere Editoren gleichzeitig:

vim config.txt &
vim script.py &
jobs

Langläufige Aufgabe im Hintergrund:

find / -name "*.log" > logs.txt 2>&1 &

Zwischen mehreren Aufgaben wechseln:

python server.py
# STRG + Z
bg
vim main.py
# STRG + Z
jobs
fg %1  # Zurück zum Server

Arbeitsumgebung und Konfiguration

1 Der which-Befehl

Der Befehl which zeigt den vollständigen Pfad des Kommandos, das übergeben wird:

which <befehlsname>

Gibt man einen Befehl im Terminal ein, sucht die Shell in allen Verzeichnissen der PATH-Variable nach einer Datei mit diesem Namen. which tut dies ebenfalls. Jedoch wird der Befehl nicht ausgeführt sondern sein Speicherort ausgegeben.

Beispiel:

which brew

liefert:

/opt/homebrew/bin/brew

Wird nach einem Shell-Builtin (einem eingebauten Befehl, welcher kein separates Programm ist) wie beispielsweise cd oder echo gesucht, wird folgendes ausgegeben:

cd: shell built-in command

Vergleich mit ähnlichen Befehlen:

2 Umgebungsvariablen

Anzeige einer Umgebungsvariable:

echo $PATH

Erweiterung von $PATH:

export PATH=$PATH:/usr/local/bin

2.1 Dauerhafte Speicherung

Nach einem Neustart sind zusätzlich hinzugefügte Pfade jedoch wieder weg. Sollen sie dauerhaft in der PATH-Variable bleiben, muss der export-Befehl in die .zshrc-Datei geschrieben werden (siehe auch Abschnitt “Die .zshrc-Datei”).

Wird die .zshrc-Datei jedoch mehr neugeladen (source ~/.zshrc), werden zusätzliche Pfade erneut hinzugefügt und kommt somit mehrfach vor. Die kann zu Problemen führen. Dieses Verhalten vermeidet man, indem vorher geprüft wird, ob der Pfad schon vorhanden ist:

# --- Custom PATH entries ------------------------------------------

# Define paths in array
CUSTOM_PATHS=(
	"/Applications/Visual Studio Code.app/Contents/Resources/app/bin"
	# "/add/additional/paths/here" (without comma; semicolon)
)

# Add all paths from CUSTOM_PATHS to PATH if it doesn't exist
for dir in "${CUSTOM_PATHS[@]}"; do
	if [-d "$dir" && ":$PATH:" != *":$dir:"*](-d%20"$dir"%20&&%20":$PATH:"%20!=%20*":$dir:"*.md); then
		export PATH="$PATH:$dir"
	fi
done

# ------------------------------------------------------------------

2.2 ~ vs. $HOME

*~ (Tilde):

• Wird von der Shell (zsh, bash etc.) automatisch expandiert.
• Funktioniert nur an positionsabhängigen Stellen (z.B. nicht innerhalb von Anführungszeichen “ “).
• Wird häufig für Navigation verwendet:

cd ~
cd ~/Downloads
ls ~

Die Shell ersetzt ~ intern automatisch durch /Users/<username>.

Sonderformen:

~user  # Home-Verzeichnis eines anderen Users (wenn zugreifbar)
~+     # aktuelles Verzeichnis
~-     # vorheriges Verzeichnis

$HOME:

• Eine Umgebungsvariable, die den kompletten Pfad enthält.
• Wird von Programmen, Skripten und Konfigurationsdateien benötigt.
• Funktioniert auch innerhalb von Strings und Skripten:

echo $HOME
cd $HOME/Documents
export PATH="$PATH:$HOME/bin"

In vielen Programmen ist $HOME die bevorzugte Form, weil sie immer eindeutig ist, auch wenn die Shell keine Tilde-Ersetzung durchführt.

3 Die .zshrc-Datei

Die Datei .zshrc ist die zentrale Konfigurationsdatei der Z-Shell (zsh). Sie wird bei jedem Start eines neuen interaktiven Terminalfensters automatisch geladen und ausgeführt. Darin lassen sich Befehle, Einstellungen, Umgebungsvariablen und Aliase dauerhaft speichern.

3.1 Speicherort

Die Datei liegt standardmäßig im Home-Verzeichnis des Benutzers:

~/.zshrc

Sollte sie nicht existieren, kann sie wie folgt erstellt werden:

touch ~/.zshrc

3.2 Zweck

In dieser Datei steht alles, was bei einem Terminalstart automatisch ausgeführt werden soll.

3.3 Änderungen übernehmen

Damit Änderungen wirksam werden, muss das Terminal neugestartet oder die Datei neugeladen werden.

Neuladen von ~/.zshrc:

source ~/.zshrc

Nützliches Aliase zum Bearbeiten und Neuladen von ~/.zshrc:

alias editrc="nano ~/.zshrc"
alias reloadrc="source ~/.zshrc"

3.4 Vergleich mit anderen Startdateien

mv ~/.zshrc ~/dotfiles/zshrc
ln -s ~/dotfiles/zshrc ~/.zshrc

. ~/.config/zsh/aliases.zsh

Admin-Rechte (sudo)

Ist man als normaler Benutzer angemeldet kann ein Befehl mit Administrator-Rechten ausgeführt werden, indem sudo (superuser do) vorangestellt wird. Da macOS ein UNIX-basiertes System ist, sind viele Systembefehle nur mit Admin-Rechten ausführbar. Sie sind auch erforderlich für den Zugriff auf geschützte Systemdateien und -einstellungen.

1 Syntax

sudo <befehl> [optionen] [argumente]

Bei der ersten Ausführung von sudo wird nach dem Administratorpasswort gefragt.

2 Beispiele

Ordner /usr/local/test mit Administratorrechten erstellen:

sudo mkdir /usr/local/test

Systemverzeichnisse ändern:

sudo nano /etc/hosts

→ Bearbeitung der Host-Datei, um z.  B. Webseiten umzuleiten.

Dienste starten/stoppen:

sudo launchctl load /Library/LaunchDaemons/meindienst.plist

Systemweite Berechtigungen ändern:

sudo chmod 755 /usr/local/bin/meinprogramm

Dateien löschen, die geschützt sind:

sudo rm -rf /Pfad/zur/Datei

3 Root-Shell und Shell mit Root-Rechten

sudo speichert die Authentifizierung kurzfristig (standardmäßig 5 Minuten = 300 Sekunden). Für häufige Admin-Aufgaben eignet sich eine Root-Shell (sudo -i) oder eine Shell mit Root-Rechten (sudo -s).

3.1 Root-Shell (sudo -i = login shell as root)

Es wird simuliert, dass man als Root-Benutzer eingeloggt ist, fast wie bei einem echten Root-Login.

Wichtige Eigenschaften:

• Es werden die Umgebungsvariablen des Root-Benutzers geladen (PATH, HOME, usw.).
• Man landet im Home-Verzeichnis des Root-Benutzers (/var/root).
• Es werden die Shell-Startdateien vom Root-Benutzer genutzt (.profile und .bashrc bzw. .zshrc)

sudo -i

• Prompt wechselt, z. B. von cgroening@macbook ~ % zu macbook:~ root#
• echo $HOME zeigt den Ordner /var/root

3.2 Shell mit Root-Rechten (sudo -s = run shell as root)

Man erhält eine Shell mit Root-Rechten.

Aber:

• Die eigenen Umgebungsvariablen bleiben aktiv.
• Man verbleibt im aktuellen Benutzerverzeichnis.
• Die Startdateien des Root-Benutzers werden nicht geladen.

sudo -s

• Prompt wechselt, z. B. von cgroening@macbook ~ % zu root@macbook ~ #
• echo $HOME zeigt den Ordner /Users/cgroening

3.3 Zusammenfassung

4 Übersicht

Berechtigungen (chmod) und Besitz (chown)

1 chmod

1.1 Rechte und Benutzergruppen

chmod steht für change mode. Mit diesem Befehl werden Datei- und Verzeichnisrechte geändert.

Es gibt drei Arten von Rechten:

1. r: read (lesen)
2. w: write (schreiben)
3. x: execute (ausführen)

Man unterscheidet drei Benutzergruppen:

1. u: user (Besitzer)
2. g: group (Gruppe)
3. o: others (alle anderen)

• a: all (alle drei Gruppen: u+g+o)

1.2 Schreibweisen

1.2.1 Symbolische Schreibweise

Es werden Buchstaben und Operatoren verwendet:

• +: Recht hinzufügen
• -: Recht entfernen
• =: Rechte gleichsetzen

Beispiele:

chmod u+x datei.sh    # Besitzer darf die Datei ausführen
chmod g-w datei.txt   # Gruppe darf nicht mehr schreiben
chmod o=r datei.txt   # Andere dürfen nur lesen
chmod a+r datei.txt   # Alle dürfen lesen

1.2.2 Oktal-/Numerische Schreibweise

Jedes Recht hat einen Zahlenwert:

Man addiert die Werte für jede Gruppe um Rechte zu setzen:

---    →    0+0+0 = 0    (keine Rechte)
--x    →    0+0+1 = 1    (nur ausführen)
-w-    →    0+2+0 = 2    (nur schreiben)
-wx    →    0+2+1 = 3    (schreiben + ausführen)
r--    →    4+0+0 = 4    (nur lesen)
r-x    →    4+0+1 = 5    (lesen + ausführen)
rw-    →    4+2+0 = 6    (lesen + schreiben)
rwx    →    4+2+1 = 7    (lesen + schreiben + ausführen)

Beispiel:

chmod 755 datei.sh

Bedeutung:

• 7 (u) → rwx → Besitzer darf alles
• 5 (g) → r-x → Gruppe darf lesen & ausführen
• 5 (o) → r-x → andere dürfen lesen & ausführen

1.3 Nützliche Operationen

-R → rekursiv (für Verzeichnisse):

chmod -R 755 /pfad/zum/verzeichnis

--reference=DATEI → Rechte von einer anderen Datei kopieren:

chmod --reference=vorlage.txt ziel.txt

-v → verbose, zeigt was geändert wurde:

chmod -v 644 datei.txt

2 chown

chown steht für change owner. Dieser Befehl ändern den Besitzer oder die Gruppe einer Datei bzw. eines Verzeichnisses.

Jede Datei hat

• einen user (Besitzer) und
• eine group (Gruppe).

2.1 Syntax

chown [OPTIONEN] BESITZER[:GRUPPE] DATEI/VERZEICHNIS

• BESITZER: neuer Benutzer, der die Datei besitzen soll
• GRUPPE: neue Gruppe, der die Datei angehören soll
• : → trennt Besitzer und Gruppe

sudo chown ...

Beispiele:

chown anna datei.txt             # Ändert den Besitzer auf anna
chown :developers datei.txt      # Ändert die Gruppe auf developers
chown anna:developers datei.txt  # Ändert Besitzer auf anna und Gruppe auf developers

2.2 Wichtige Optionen

Beispiel für Rekursiv:

chown -R anna:developers /home/anna/projekt

Alle Dateien und Unterverzeichnisse gehören danach dem Benutzer anna und der Gruppe developers.

Beispiel für --reference:

chown --reference=vorlage.txt ziel.txt

Besitzer & Gruppe wie bei vorlage.txt gesetzt.

3 ACL

ACL steht für Access Control List (Zugriffssteuerungsliste). Sie erweitert das klassische UNIX-Berechtigungssystem (Lesen, Schreiben, Ausführen für Benutzer / Gruppe / andere) um feinere Zugriffsrechte.

Während das herkömmliche System nur drei Berechtigungsebenen kennt (z. B. rw-r--r--), kann eine ACL mehreren einzelnen Benutzern oder Gruppen ganz spezifische Rechte zuweisen.

Beispiel:

Angenommen man hat die folgende Datei:

-rw-r--r--  user  staff  dokument.txt

Es darf nur user schreiben, alle anderen dürfen nur lesen. Mit einer ACL kann man z. B. einem zusätzlichen andern Benutzer wie john Schreibrechte geben:

chmod +a "alex allow write" dokument.txt

Der Befehl ls -le liefert dadurch die folgende Ausgabe:

-rw-r--r--+  user  staff  dokument.txt
  0: john allow write

Das Pluszeichen (+) hinter den Berechtigungen zeigt an, dass eine ACL vorhanden ist.

3.1 Typische Befehle

Aliase, Pipes, Weiterleitungen und Verkettungen

1 Aliase

Ein Alias ist ein benutzerdefinierter Kurzbefehl. Er ersetzt längere und/oder häufig genutzt Terminal befehle durch ein Kürzel.

1.1 Typische Aliase (Beispiele)

alias ll="ls -lah"
alias la="ls -A"
alias gs="git status"
alias gp="git pull"
alias v="nvim"
alias ..="cd .."
alias ...="cd ../.."

Es sind auch dynamische Aliase möglich:

alias now='date "+%Y-%m-%d %H:%M:%S"'
alias weather='curl wttr.in'

1.2 Dauerhafte Speicherung von Aliasen

Damit die Aliase bei jedem Start verfügbar sind, müssen sie in die ~/.zshrc eingefügt werden (siehe auch Abschnitt “Die .zshrc-Datei”).

Öffnen von ~/.zshrc:

nano ~/.zshrc

Anschließend zum Beispiel:

# Eigene Aliase
alias editrc="nano ~/.zshrc"
alias reloadrc="source ~/.zshrc"
alias openfl="open -a ForkLift ."

Neuladen:

source ~/.zshrc

2 Pipes (|) – Kombination von Kommandos

Mit dem Pipe-Zeichen (|) wird die Ausgabe eines Befehls als Eingabe für den nächsten Befehl weitergeleitet. Auf diese Weise kann man kleine Werkzeuge zu sehr mächtigen Befehlen kombinieren.

2.1 Beispiele

Alle Dateien auflisten und nach Dateiendung .txt filtern:

ls | grep txt

• ls: listet alle Dateien und Ordner im aktuellen Verzeichnis auf
• grep txt: filtert die Ausgabe und zeigt nur Zeilen an, die „txt“ enthalten (d. h. .txt-Dateien)

Prozesse anzeigen, die “Safari” enthalten:

ps aux | grep Safari

• ps aux: zeigt alle laufenden Prozesse im System mit Benutzer, PID, CPU- und Speicherverbrauch
• grep Safari: filtert die Prozessliste und zeigt nur Zeilen, in denen “Safari” vorkommt

Zählen, wie viele Zeilen im Log das Wort “ERROR” enthalten:

cat access.log | grep "ERROR" | wc -l

• cat access.log: gibt den gesamten Inhalt der Datei access.log aus
• grep "ERROR": filtert alle Zeilen, die das Wort „ERROR“ enthalten
• wc -l: zählt die Anzahl der Zeilen der gefilterten Ausgabe (d. h. die Anzahl der Fehlermeldungen)

Pipes können beliebig verkettet werden. Somit sind sie in Kombination mit grep, awk, sed, sort, uniq, cut usw. sehr mächtig.

2.2 Relevante Befehle für Pipes

2.2.1 grep

Durchsucht Textzeilen nach Mustern oder Wörtern. Unterstützt reguläre Ausdrücke.

Syntax:

grep [Optionen] Muster [Datei(en)]

Häufige Optionen:

• -i: Groß-/Kleinschreibung ignorieren
• -r: rekursiv durchsuchen
• -n: Zeilennummern anzeigen

Beispiele:

grep "error" /var/log/system.log
ps aux | grep Safari

Siehe auch grep-Beispiele.

2.2.2 awk

Zeilen- und spaltenorientierter Textprozessor, ideal für Auswertungen oder Filterung.

Syntax:

awk '{Aktion}' [Datei]

Beispiele:

ls -l | awk '{print $9, $5}'      # Dateiname + Größe
df -h | awk '{print $1, $5}'      # Laufwerk + Auslastung

2.2.3 sed

Stream-Editor zum automatischen Bearbeiten von Texten in Datenströmen.

Syntax:

sed 's/ALT/NEU/g' [Datei]

Häufige Optionen:

• -i: Änderungen direkt in der Datei speichern
• -n: unterdrückt Standardausgabe

Beispiele:

cat config.txt | sed 's/enabled=false/enabled=true/g'
sed -i '' 's/http:/https:/g' urls.txt

2.2.4 sort

Sortiert Zeilen alphabetisch oder numerisch.

Syntax:

sort [Optionen] [Datei]

Syntax:

• -n: numerisch sortieren
• -r: Reihenfolge umkehren

Beispiele:

cat names.txt | sort
ls -l | sort -k5 -n

2.2.5 uniq

Entfernt aufeinanderfolgende Duplikate aus sortierten Listen.

Syntax:

uniq [Optionen] [Datei]

Häufige Optionen:

• -c: zählt Vorkommen
• -d: zeigt nur doppelte Einträge

Beispiele:

sort names.txt | uniq
sort names.txt | uniq -c

2.2.6 cut

Extrahiert Spalten aus Textzeilen – besonders nützlich bei CSV-Dateien.

Syntax:

cut -d[Trennzeichen] -f[Feldnummer] [Datei]

Häufige Optionen:

• -d: legt das Trennzeichen fest (z. B. , oder :)
• -f: bestimmt die Spaltennummer(n)

Beispiele:

cat users.csv | cut -d',' -f1     # erste Spalte (Name)
ps aux | cut -c1-10               # Zeichen 1–10 jeder Zeile

3 Weiterleitungen (>, >>, <)

Weiterleitungen bestimmen, wohin die Eingaben oder Ausgaben eines Befehls gehen.

3.1 Arten von Weiterleitungen

3.2 Beispiele

Die Namen aller JPEG-Dateien in eine Textdatei schreiben:

find . -name "*.jpg" > bilder.txt

Gefundene Warnungen aus einem Log an eine Textdatei anhängen:

grep "WARN" log.txt >> warnungen.txt

Aus input.txt lesen und in output.txt schreiben:

cat < input.txt > output.txt

Stumme Ausführung eines Befehls (keine Ausgabe, d. h. keine sichtbare Fehlermeldung):

befehl &> /dev/null

4 Verkettung von Befehlen – AND (&&) und OR (||)

mkdir ordner123 && cd ordner123  # Ordner erstellen und hineinwechseln
cd ordner123 || mkdir ordner123  # In Ordner wechseln oder erstellen, wenn er nicht existiert

Packetmanagement mit Homebrew

Das Software-Installationssystem Homebrew bezeichnet sich selbst als “The Missing Package Manager for macOS (or Linux)” und ist unter macOS der inoffizielle Standard für die Installation von Software über das Terminal. Homebrew macht die Kommandozeile zu einer echten Linux-ähnlichen Umgebung. Es verwaltet Programme, Bibliotheken und Entwicklerwerkzeuge – alles über einfache Befehle.

Installation von Homebrew:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Überprüfung, ob alles korrekt eingerichtet ist:

brew doctor

Wesentliche Vorteile von Homebrew:

• Sehr schnelle Installation von Software (deutlich schneller als manuell)
• Ermöglicht ein konsistentes Setup über mehrere Rechner hinweg
• Hat eine riesige Community und Tausende Pakete

1 Grundlegende Befehle

GUI-Apps über Homebrew Cask:

brew install --cask visual-studio-code
brew install --cask google-chrome
brew install --cask rectangle

--cask = für Anwendungen mit Benutzeroberfläche.

2 Paketpfade & Umgebungsvariablen

Homebrew installiert standardmäßig nach:

• /usr/local (bei Intel-Macs)
• /opt/homebrew (bei Apple Silicon)

Über eine Umgebungsvariable in der ~/.zshrc kann man den Installationspfad anpassen:

export PATH="/opt/homebrew/bin:$PATH"

3 Backup und Wiederherstellung

Liste aller installierten Pakete erstellen:

brew bundle dump --file=~/brewfile.txt

Um die vorhandene Datei zu überschreiben:

brew bundle dump --file=~/brewfile.txt --force

Wiederherstellung der Installation:

brew bundle --file=~/brewfile.txt

4 Kombinationsbeispiel: Homebrew + Alias + Pipe

Auf veraltete Pakete prüfen:

alias brewoutdated="brew outdated | grep -vE 'python|node'"

Automatisches Aufräumen:

alias brewclean="brew cleanup && brew autoremove && brew doctor"

Tipps und Tools für maximale Effizienz

1 Kurzbefehle im Terminal

1.1 Navigation und Bearbeitung

1.2 History-Navigation

1.3 Tab-Vervollständigung

1.4 Praktische Kombinationen

Letzten Befehl mit sudo wiederholen:

apt update
# Permission denied
sudo !!

Argument vom letzten Befehl übernehmen:

cat /etc/hosts
vim !$    # öffnet /etc/hosts in vim

In der History suchen:

# STRG + R drücken, dann tippen:
(reverse-i-search)`brew': brew install htop

2 Dokumentation

2.1 man – Handbuch zu beliebigem Befehl anzeigen

man grep

Navigation im Handbuch:

• Leertaste: Nächste Seite
• b: Vorherige Seite
• /: Vorwärts suchen
• ?: Rückwärts suchen
• n: Nächstes Suchergebnis
• N: Vorheriges Suchergebnis
• q: Beenden

Manpage-Sektionen:

man 1 printf    # Benutzerkommandos
man 2 open      # Systemaufrufe
man 3 printf    # Bibliotheksfunktionen

2.2 whatis – Kurzbeschreibung

Zeigt eine einzeilige Beschreibung eines Befehls:

whatis ls
# ls(1) - list directory contents

whatis grep sed awk
# grep(1) - file pattern searcher
# sed(1) - stream editor
# awk(1) - pattern-directed scanning and processing language

2.3 apropos – Befehle suchen

Durchsucht die Manpage-Datenbank nach Stichwörtern:

apropos network
apropos "copy files"
apropos -s 1 search    # Nur in Sektion 1 suchen

Nützlich, wenn man nicht genau weiß, welcher Befehl benötigt wird.

2.4 tldr – Vereinfachte Hilfe mit Beispielen

tldr (Too Long; Didn’t Read) bietet prägnante, praxisorientierte Hilfe mit Beispielen.

Installation:

brew install tldr

Verwendung:

tldr tar
tldr find
tldr git-commit

Beispielausgabe für tar:

tar

Archiving utility.
Often combined with a compression method, such as gzip or bzip2.
More information: https://www.gnu.org/software/tar.

- Create an archive from files:
  tar cf target.tar file1 file2 file3

- Create a gzipped archive:
  tar czf target.tar.gz file1 file2 file3

- Extract an archive:
  tar xf source.tar

Cache aktualisieren:

tldr --update

2.5 Vergleich der Dokumentations-Tools

3 Empfohlener Workflow

1. Unbekannter Befehl: tldr <befehl> für schnelle Orientierung
2. Befehl finden: apropos <stichwort> zum Suchen
3. Details nachschlagen: man <befehl> für vollständige Dokumentation
4. Kurze Info: whatis <befehl> für Einzeiler

4 Finder

Aktuellen Ordner oder ausgewählte Datei im Finder öffnen:

• Rechtsklick auf Ordner oder Datei in Pfadleiste :luc_arrow_right: “In Terminal öffnen”
• oder: Rechtsklick auf Ordner oder Datei in Pfadleiste :luc_arrow_right: “Dienste” :luc_arrow_right: “New Warp Tab Here”

5 tee-Befehl

Der tee-Befehl funktioniert als “T-Stück” für Datenströme. Er dupliziert die Ausgabe eines Befehls und sendet diese

• ins Terminal (stdout) und
• an eine andere Ziel (Datei, Pipe, usw.).

Dies ist besonders hilfreich bei Aliasen, Shell-Funktionen und Skripten.

Beispiel:

alias copypwd='pwd | tee >(pbcopy)'

Der aktuelle Pfad wird in die Zwischenablage kopiert und im Terminal ausgegeben. Mit pwd | pbcopy, d. h. ohne tee, wird nur der Pfad kopiert, aber nicht ausgegeben.

6 Ausführung von AppleScript

AppleScript- oder JXA-Code (JXA = JavaScript for Automation) kann mit dem Befehl osascript ausgeführt werden.

Syntax:

osascript [Optionen] [Datei | -e "Skript-Code"]

Ein Skript aus einer Datei ausführen:

osascript ~/Skripte/mein_skript.scpt

Beispiel:

Anzeige des Titels des aktuellen Songs aus Apple Music:

osascript -e 'tell application "Music" to get name of current track'

Optionen:

• -e: Führe eine oder mehrere Codezeilen direkt aus.

• -l JavaScript: Verwende JavaScript statt AppleScript

  Beispiel: osascript -l JavaScript -e 'Application("Finder").open("/Applications")'

6.1 Mitteilungen

Mittels Apple Script ist es auch möglich, Mitteilungen, die rechts oben auf dem Bildschirm erscheinen, auszugeben:

osascript -e 'display notification "Hallo!"'

6.2 Typische Anwendungsfälle

• Automatisierung von Aufgaben von macOS-Apps (z. B. Fenster öffnen, Dateien verschieben)
• Systemdialoge oder Benachrichtigungen aus Skripten heraus anzeigen
• Kombination von Terminal-Befehle mit macOS-Funktionen (z. B. GUI-Interaktionen)
• Integration in Shell-Skripte und Workflows

7 Brace Expansion – Effiziente Musterbildung

Brace Expansion ist ein mächtiges Shell-Feature zum schnellen Erzeugen von Mustern und Sequenzen.

7.1 Zahlensequenzen

echo {1..10}              # 1 2 3 4 5 6 7 8 9 10
echo {01..10}             # 01 02 03 04 05 06 07 08 09 10
echo {10..1}              # Rückwärts: 10 9 8 7 6 5 4 3 2 1
echo {a..z}               # Buchstaben: a b c d ... z
echo {2..20..2}           # Schrittweite: 2 4 6 8 10 12 14 16 18 20

7.2 Listen

echo {rot,grün,blau}      # rot grün blau
mkdir {Docs,Images,Videos}

7.3 Kombinationen

echo {A,B}{1,2}           # A1 A2 B1 B2
mkdir Jahr_{2023,2024}/{Q1,Q2,Q3,Q4}

7.4 Praktische Anwendungen

Backup erstellen:

cp wichtig.txt{,.backup}  # Kopiert nach wichtig.txt.backup

Mehrere Dateien auf einmal umbenennen:

mv bild.{jpg,png}         # Umbenennen von jpg zu png

Batch-Download:

curl https://example.com/file{001..100}.jpg -O

Projektstruktur anlegen:

mkdir -p projekt/{src,tests,docs}/{backend,frontend}

Beispiele für alltägliche Aufgaben im Terminal

1 Dateien suchen

Im aktuellen Ordner sollen alle Dateien vom Typ PDF gefunden werden.

1.1 GUI

• Finder öffnen :luc_arrow_right: im Eingabefeld für die Suche rechts oben “.pdf” eingeben
• Weitere Verfeinerungen über Filter möglich (+-Button)

1.2 Terminal

find . -name "*.pdf"

:luc_arrow_right: Listet alle PDF-Dateien (auch in Unterordnern)

Bis hier ist der Aufwand gleich. Das Terminal ist jedoch deutlich schneller, wenn zusätzlich alle Dateien gefunden werden sollen, die einen bestimmten Dateiinhalt haben.

Beispiel:

find . -name "*.pdf" -exec grep -Hn "Rechnung" {} \

2 Zuletzt bearbeitete Dateien anzeigen

Es sollen alle JPEG-Dateien eines Ordners angezeigt werden, die in den letzten 10 Minuten bearbeitet wurden. Anschließend sollen diese in der Vorschau-App geöffnet werden.

2.1 GUI

1. Im Finder in die Listenansicht wechseln und die Spalte “Änderungsdatum” anzeigen lassen, falls noch nicht vorhanden
2. Auf die Spaltenüberschrift klicken, um nach Änderungsdatum zu sortieren
3. Die Datei mit dem ältesten Änderungsdatum, das in Frage kommt, suchen
4. Auswählen von dieser Datei und allen, die sich davor/dahinter befinden
5. Rechtsklick :luc_arrow_right: Öffnen mit :luc_arrow_right: Vorschau.app
6. Zurück zum Finder wechseln und alle ursprünglichen Darstellungseinstellungen wiederherstellen

2.2 Terminal

Alle JPEG-Dateien anzeigen, die nicht älter als 10 Minuten sind:

find . -type f -iname "*.jpeg" -mmin -10

Sollen Dateien mit den Endungen .jpg und .jpeg angezeigt werden, muss der Befehl wie folgt erweitert werden:

find . -type f \( -iname "*.jpg" -o -iname "*.jpeg" \) -mmin -10

Genau diese Dateien in der Vorschau-App öffnen:

find . -type f -iname "*.jpeg" -mmin -10 -print0 | xargs -0 open -a Preview

2.2.1 Alias

Besonders schnell und einfach erfolgt es, wenn man sich einen Alias erstellt:

alias showrecent='find . -type f -iname "*.jpg" -mmin $1'

Komfortabler ist es in diesem Fall, wenn man stattdessen Funktionen erstellt:

showrecent () {
	echo "The following files were modified in the past $1 minutes:"
	find . -type f -iname "*.*" -mmin -$1
}

openrecentjpg () {
	echo "Opening the following files in preview:"
	find . -type f \( -iname "*.jpg" -o -iname "*.jpeg" \) -mmin -$1
	find . -type f \( -iname "*.jpg" -o -iname "*.jpeg" \) -mmin -$1 -print0 | xargs -0 open -a Preview
}

Verwendung:

showrecent 10

openrecentjpg 10

Beispielausgabe:

ls

IMG_7094.jpeg		IMG_7096 Kopie.jpeg	IMG_7097.jpeg		IMG_7099.jpeg
IMG_7095.jpeg		IMG_7096.jpeg		IMG_7099 Kopie.jpeg

showrecent 10

The following files were modified in the past 10 minutes:
./IMG_7099 Kopie.jpeg
./IMG_7096 Kopie.jpeg

openrecentjpg 10

Opening the following files in preview:
./IMG_7099 Kopie.jpeg
./IMG_7096 Kopie.jpeg

unalias <aliasname>

Shell-Scripting

1 Motivation & Abgrenzung: Shell-Scripting vs. Python

Auch wenn man Python beherrscht, lohnt es sich, Shell-Scripting zu lernen. Beide haben unterschiedliche Stärken und Einsatzzwecke und werden in der Praxis sehr häufig kombiniert, statt sich gegenseitig zu ersetzen.

Grundlegende Unterschiede:

2 was kann shell-scripting besser als python?

2.1 1. Schnelle Systembefehle und Administrative Tasks:

Beispiel: fünf Dateien verschieben und einen Dienst neu starten:

mv *.log /backup/logs && systemctl restart apache2

In Python ist es deutlich umständlicher:

import glob
import shutil
import subprocess

# Find all .log files
for file in glob.glob('*.log'):
    shutil.move(file, '/backup/logs')

# Restart service
result = subprocess.run(
    ['systemctl', 'restart', 'apache2'], capture_output=True, text=True
)

if result.returncode == 0:
    print('Service started.')
else:
    print('Error: ', result.stderr)

Hier kann man klar sehen, dass Shell-Scripting bei einfachen Systemaufgaben schneller und präziser ist, während Python mehr Kontrolle und Fehlerbehandlung ermöglicht, aber auch mehr Code erfordert.

2.1.1 2. Pipelines und Stream-Verarbeitung:

Shell + Tools sind darauf optimiert, Streams zu verarbeiten, z. B.:

ps aux | grep python | awk '{print $2}' | xargs kill

In Python müsste man Prozesse einlesen, parsen, filtern, Subprozesse starten …

2.1.2 3. Automatisierung in Systemstart, Cron, Deployment:

• cronjobs
• launchd
• systemd
• Installationsskripte (install.sh sind Standard)

2.1.3 4. Universelle Verfügbarkeit

Shell steht auf jedem Server bereit. Python nicht immer.

Shell-Scripting ist

• essentiell für DevOps, Sysadmins, Server & Deployment;
• perfekt für kleine Tools, Setup-Skripte und wiederkehrende Aufgaben;
• unverzichtbar für CI/CD & Cloud und
• enorm zeitsparend bei Routine-Aufgaben.

2.2 Was kann Python besser als Shell?

Python ist ideal für:

• komplexe Logik & Algorithmen
• APIs & Webservices
• Datenanalyse & Machine Learning
• GUI-Tools
• saubere Tests & Wartbarkeit

Beispiel: JSON-Parsing in Python:

import json
data = json.loads(json_string)

In Shell wäre das schwierig und fehleranfälliger. Es ist jq erforderlich (Kommandozeilenwerkzeug zur Verarbeitung von JSON-Daten).

2.3 Warum beides kombinieren?

Man muss sich nicht entscheiden: Häufig wird beides verwendet ⇒ Best-of-Both-Worlds.

Python aus einem Shell-Script heraus aufrufen:

#!/bin/zsh
echo "Starte Datenverarbeitung..."
python3 analyse.py input.csv
echo "Fertig!"

Shell aus Python heraus verwenden:

import subprocess
subprocess.run(["ls", "-la"])

Python als Tool + Shell als Wrapper (häufigste Variante):

#!/bin/zsh
INPUT=$1
python3 process.py "$INPUT" | tee results.txt

• Shell übernimmt Dateihandling und Prozesslogik
• Python rechnet, verarbeitet, analysiert

2.4 Zusammenfassung

Es ist wie ein Schraubendrehen vs. Akkuschrauber:

• Beides sind Werkzeuge.
• Shell = leicht, schnell, überall verfügbar
• Python = leistungsstark, modular, bei großen Aufgaben überlegen

Empfehlung:

• Shell für kleine Automatisierungen (10–50 Zeilen)
• Python für komplexe Logik, APIs, Datenverarbeitung, ML
• Beides kombinieren für professionelle DevOps-Workflows

3 Grundlagen des Shell-Scripting

Ein Shell-Skript ist eine Textdatei mit einer Folge von Befehlen, die nacheinander ausgeführt werden. Skripte ermöglichen die Automatisierung wiederkehrender Aufgaben und können beliebig komplex werden.

Minimales Beispiel:

#!/bin/zsh
echo "Hallo Welt"

3.1 Aliase vs. Funktionen

Sowohl Aliase als auch Funktionen dienen dazu, häufig verwendete Befehle abzukürzen. Sie unterscheiden sich jedoch in ihren Möglichkeiten.

Aliase:

Ein Alias ist eine einfache Textersetzung. Er eignet sich für kurze, statische Befehlsketten.

# Definition
alias ll="ls -lah"
alias gs="git status"
alias ..="cd .."

# Verwendung
ll
gs
..

Einschränkungen von Aliasen:

• Keine Argumente an beliebiger Stelle möglich
• Keine Kontrollstrukturen (if, for, while)
• Keine lokalen Variablen

# Das funktioniert NICHT wie erwartet:
alias greet="echo Hallo $1"  # $1 wird sofort ausgewertet, nicht beim Aufruf

Funktionen:

Funktionen sind flexibler und ermöglichen komplexere Logik mit Argumenten, Variablen und Kontrollstrukturen.

# Definition
greet() {
    echo "Hallo $1!"
}

# Verwendung
greet "Welt"    # Ausgabe: Hallo Welt!
greet "Max"     # Ausgabe: Hallo Max!

Beispiel mit mehreren Argumenten:

mkcd() {
    mkdir -p "$1" && cd "$1"
}

# Verwendung
mkcd neuer_ordner  # Erstellt Ordner und wechselt hinein

Beispiel mit Kontrollstruktur:

backup() {
    if [-z "$1"](-z%20"$1".md); then
        echo "Fehler: Kein Dateiname angegeben"
        return 1
    fi
    cp "$1" "$1.bak"
    echo "Backup erstellt: $1.bak"
}

Vergleich:

Faustregel:

• Alias: Für einfache Abkürzungen ohne Argumente
• Funktion: Sobald Argumente, Logik oder Variablen benötigt werden

Speicherort:

Beide werden typischerweise in ~/.zshrc definiert. Bei vielen Aliasen und Funktionen empfiehlt sich eine Auslagerung:

# In ~/.zshrc
source ~/.config/zsh/aliases.zsh
source ~/.config/zsh/functions.zsh

Einbindung in .zshrc:

SCRIPT_DIR="/parent/folder/of/zshrc"
source "$SCRIPT_DIR/aliases.zsh"
source "$SCRIPT_DIR/functions.zsh"

4 Variablen

Variablen speichern Werte, die im Skript wiederverwendet werden können.

4.1 Variablenzuweisung

# Richtig
name="Max"
zahl=42
pfad="/Users/max/Documents"

# FALSCH – führt zu Fehlern
name = "Max"    # Fehler: "name" wird als Befehl interpretiert

Variablen verwenden:

name="Max"
echo "Hallo $name"           # Ausgabe: Hallo Max
echo "Hallo ${name}!"        # Ausgabe: Hallo Max!
echo "Pfad: ${name}_backup"  # Geschweifte Klammern bei Verkettung

Befehlsausgabe in Variable speichern:

# Moderne Syntax (empfohlen)
datum=$(date +%Y-%m-%d)
dateien=$(ls -1 | wc -l)

# Alte Syntax (Backticks) – funktioniert, aber weniger lesbar
datum=`date +%Y-%m-%d`

echo "Heute ist $datum"
echo "Anzahl Dateien: $dateien"

Rechnen mit Variablen:

a=5
b=3

# Arithmetische Auswertung
summe=$((a + b))
produkt=$((a * b))

echo "Summe: $summe"       # Ausgabe: Summe: 8
echo "Produkt: $produkt"   # Ausgabe: Produkt: 15

4.2 Environment-Variablen vs. lokale Variablen

Lokale Variablen:

Lokale Variablen existieren nur in der aktuellen Shell oder Funktion. Sie werden nicht an Kindprozesse vererbt.

meine_var="lokal"
echo $meine_var  # Funktioniert

# In einem Subprozess:
bash -c 'echo $meine_var'  # Ausgabe: (leer)

Environment-Variablen (exportiert):

Mit export wird eine Variable zur Environment-Variable. Sie wird an alle Kindprozesse vererbt.

export MEINE_VAR="global"
echo $MEINE_VAR  # Funktioniert

# In einem Subprozess:
bash -c 'echo $MEINE_VAR'  # Ausgabe: global

Wichtige System-Environment-Variablen:

Alle Environment-Variablen anzeigen:

env
printenv

Lokale Variablen in Funktionen:

Mit local wird eine Variable auf die Funktion beschränkt:

test_funktion() {
    local lokale_var="nur hier sichtbar"
    globale_var="überall sichtbar"
    echo "In Funktion: $lokale_var"
}

test_funktion
echo "Außerhalb: $lokale_var"   # Ausgabe: (leer)
echo "Außerhalb: $globale_var"  # Ausgabe: überall sichtbar

5 Strings

5.1 Strings über mehrere Zeilen

Methode 1: Here-Document (heredoc):

cat << EOF
Dies ist ein mehrzeiliger Text.
Er kann Variablen enthalten: $USER
Und mehrere Zeilen umfassen.
EOF

In Variable speichern:

text=$(cat << EOF
Zeile 1
Zeile 2
Zeile 3
EOF
)

echo "$text"

Ohne Variablenexpansion (Anführungszeichen um EOF):

cat << 'EOF'
Hier wird $USER NICHT ersetzt.
Alles bleibt literal.
EOF

Methode 2: Anführungszeichen:

text="Zeile 1
Zeile 2
Zeile 3"

echo "$text"

Methode 3: String-Verkettung:

text="Zeile 1\n"
text+="Zeile 2\n"
text+="Zeile 3"

echo -e "$text"  # -e interpretiert \n als Zeilenumbruch

5.2 String-Interpolation

Einfache Anführungszeichen vs. doppelte Anführungszeichen:

name="Max"

# Doppelte Anführungszeichen: Variablen werden ersetzt
echo "Hallo $name"    # Ausgabe: Hallo Max

# Einfache Anführungszeichen: Alles literal
echo 'Hallo $name'    # Ausgabe: Hallo $name

Geschweifte Klammern für Eindeutigkeit:

frucht="Apfel"

echo "$fruchtmus"     # Fehler: Variable $fruchtmus existiert nicht
echo "${frucht}mus"   # Korrekt: Apfelmus

Befehlssubstitution im String:

echo "Heute ist $(date +%A)"           # Ausgabe: Heute ist Montag
echo "Es gibt $(ls | wc -l) Dateien"   # Ausgabe: Es gibt 42 Dateien

Arithmetik im String:

echo "5 + 3 = $((5 + 3))"  # Ausgabe: 5 + 3 = 8

String-Manipulationen in zsh:

text="Hallo Welt"

# Länge
echo ${#text}              # Ausgabe: 10

# Substring (0-basiert)
echo ${text:0:5}           # Ausgabe: Hallo
echo ${text:6}             # Ausgabe: Welt

# Ersetzen
echo ${text/Welt/Max}      # Ausgabe: Hallo Max
echo ${text//l/L}          # Alle ersetzen: HaLLo WeLt

# Groß-/Kleinschreibung (zsh)
echo ${text:u}             # Ausgabe: HALLO WELT
echo ${text:l}             # Ausgabe: hallo welt

6 Argumente verarbeiten

Skripte und Funktionen können Argumente entgegennehmen, die beim Aufruf übergeben werden.

6.1 Zugriff über $1, $2 …

Die übergebenen Argumente sind über nummerierte Variablen zugänglich:

Beispiel:

#!/bin/zsh
# Datei: greet.sh

echo "Skriptname: $0"
echo "Erstes Argument: $1"
echo "Zweites Argument: $2"
echo "Anzahl Argumente: $#"

Aufruf:

./greet.sh Hallo Welt
# Ausgabe:
# Skriptname: ./greet.sh
# Erstes Argument: Hallo
# Zweites Argument: Welt
# Anzahl Argumente: 2

Prüfen ob Argument vorhanden:

#!/bin/zsh

if [-z "$1"](-z%20"$1".md); then
    echo "Fehler: Kein Argument angegeben"
    echo "Verwendung: $0 <name>"
    exit 1
fi

echo "Hallo $1!"

6.2 $@ und $*

Beide repräsentieren alle übergebenen Argumente, verhalten sich aber unterschiedlich:

$@ – Jedes Argument separat (empfohlen):

#!/bin/zsh
# Datei: args.sh

echo "Mit \$@:"
for arg in "$@"; do
    echo "  Argument: '$arg'"
done

Aufruf:

./args.sh "Hallo Welt" foo bar
# Ausgabe:
#   Argument: 'Hallo Welt'
#   Argument: 'foo'
#   Argument: 'bar'

$* – Alle Argumente als ein String:

#!/bin/zsh

echo "Mit \$*:"
for arg in "$*"; do
    echo "  Argument: '$arg'"
done

Aufruf:

./args.sh "Hallo Welt" foo bar
# Ausgabe:
#   Argument: 'Hallo Welt foo bar'

Zusammenfassung:

In der Regel wird "$@" verwendet.

Alle Argumente an anderen Befehl weitergeben:

#!/bin/zsh
# Wrapper-Skript

echo "Starte Programm mit allen Argumenten..."
/pfad/zum/programm "$@"

6.3 Optionen parsen (getopts)

Für Skripte mit Optionen (z. B. -v, -f datei) bietet getopts eine strukturierte Lösung.

Grundsyntax:

while getopts "vf:o:" opt; do
    case $opt in
        v) verbose=true ;;
        f) input_file="$OPTARG" ;;
        o) output_file="$OPTARG" ;;
        ?) echo "Ungültige Option"; exit 1 ;;
    esac
done

Erklärung:

• v – Option ohne Wert (Flag)
• f: – Option mit erforderlichem Wert (Doppelpunkt)
• $OPTARG – Enthält den Wert der Option

Vollständiges Beispiel:

#!/bin/zsh
# Datei: prozess.sh

# Standardwerte
verbose=false
input_file=""
output_file="output.txt"

# Hilfe-Funktion
show_help() {
    echo "Verwendung: $0 [-v] [-f eingabe] [-o ausgabe]"
    echo ""
    echo "Optionen:"
    echo "  -v          Ausführliche Ausgabe"
    echo "  -f DATEI    Eingabedatei (erforderlich)"
    echo "  -o DATEI    Ausgabedatei (Standard: output.txt)"
    echo "  -h          Diese Hilfe anzeigen"
}

# Optionen parsen
while getopts "vf:o:h" opt; do
    case $opt in
        v) verbose=true ;;
        f) input_file="$OPTARG" ;;
        o) output_file="$OPTARG" ;;
        h) show_help; exit 0 ;;
        ?) show_help; exit 1 ;;
    esac
done

# Restliche Argumente (nach den Optionen)
shift $((OPTIND - 1))
remaining_args="$@"

# Validierung
if [-z "$input_file"](-z%20"$input_file".md); then
    echo "Fehler: Eingabedatei erforderlich (-f)"
    exit 1
fi

# Hauptlogik
if $verbose; then
    echo "Eingabe: $input_file"
    echo "Ausgabe: $output_file"
    echo "Weitere Argumente: $remaining_args"
fi

echo "Verarbeite $input_file..."

Aufruf:

./prozess.sh -v -f input.txt -o result.txt zusatz1 zusatz2

7 Rückgabewerte und Exit-Codes

Jeder Befehl in Unix gibt einen Exit-Code zurück, der Erfolg oder Misserfolg signalisiert.

7.1 exit und $?

Exit-Codes:

$? – Exit-Code des letzten Befehls:

ls /existiert
echo $?  # Ausgabe: 0 (Erfolg)

ls /existiert_nicht
echo $?  # Ausgabe: 1 (Fehler)

exit in Skripten:

#!/bin/zsh

if [! -f "$1"](!%20-f%20"$1".md); then
    echo "Fehler: Datei nicht gefunden"
    exit 1
fi

echo "Datei gefunden"
exit 0

return in Funktionen:

Funktionen verwenden return statt exit:

pruefe_datei() {
    if [-f "$1"](-f%20"$1".md); then
        return 0  # Erfolg
    else
        return 1  # Fehler
    fi
}

if pruefe_datei "test.txt"; then
    echo "Datei existiert"
else
    echo "Datei nicht gefunden"
fi

Exit-Code direkt in Bedingung:

if grep -q "suchbegriff" datei.txt; then
    echo "Gefunden"
else
    echo "Nicht gefunden"
fi

7.2 Fehlerbehandlung

Befehlsverkettung mit && und ||:

# && – Nächster Befehl nur bei Erfolg
mkdir neuer_ordner && cd neuer_ordner && echo "Erfolgreich"

# || – Nächster Befehl nur bei Fehler
cd /existiert_nicht || echo "Verzeichnis nicht gefunden"

# Kombination
cd /verzeichnis && echo "OK" || echo "Fehler"

Prüfung mit if:

#!/bin/zsh

if ! command -v git &> /dev/null; then
    echo "Git ist nicht installiert"
    exit 1
fi

echo "Git ist verfügbar"

Fehlerausgabe umleiten:

# Nur Fehler unterdrücken
befehl 2>/dev/null

# Alles unterdrücken
befehl &>/dev/null

# Fehler in Datei schreiben
befehl 2>> fehler.log

8 Ausführen und Debuggen

8.1 chmod +x

Bevor ein Skript direkt ausgeführt werden kann, muss es als ausführbar markiert werden:

# Ausführbar machen
chmod +x mein_skript.sh

# Ausführen
./mein_skript.sh

Alternativ ohne chmod:

zsh mein_skript.sh
bash mein_skript.sh

Berechtigungen prüfen:

ls -l mein_skript.sh
# -rwxr-xr-x  1 user  staff  123 Jan 1 12:00 mein_skript.sh
#  ^^^
#  Die x's zeigen Ausführbarkeit an

8.2 set -x Debugging

Mit set -x wird jeder ausgeführte Befehl vor der Ausführung angezeigt:

#!/bin/zsh
set -x  # Debug-Modus aktivieren

name="Max"
echo "Hallo $name"
datum=$(date)
echo "Datum: $datum"

Ausgabe:

+name=Max
+echo 'Hallo Max'
Hallo Max
+date
+datum='Mon Jan 1 12:00:00 CET 2024'
+echo 'Datum: Mon Jan 1 12:00:00 CET 2024'
Datum: Mon Jan 1 12:00:00 CET 2024

Debug-Modus ein-/ausschalten:

set -x  # Aktivieren
# ... Debug-relevanter Code ...
set +x  # Deaktivieren

Nur beim Aufruf aktivieren:

zsh -x mein_skript.sh
bash -x mein_skript.sh

8.3 Fehlerbehandlung (set -e, trap)

set -e – Bei Fehler abbrechen:

Standardmäßig läuft ein Skript weiter, auch wenn ein Befehl fehlschlägt. Mit set -e wird bei jedem Fehler abgebrochen:

#!/bin/zsh
set -e

echo "Schritt 1"
falsch_geschriebener_befehl  # Skript bricht hier ab
echo "Schritt 2"             # Wird nicht erreicht

set -u – Fehler bei undefinierten Variablen:

#!/bin/zsh
set -u

echo $undefinierte_variable  # Skript bricht ab

set -o pipefail – Pipe-Fehler erkennen:

#!/bin/zsh
set -o pipefail

# Ohne pipefail: Exit-Code ist 0 (von wc)
# Mit pipefail: Exit-Code ist 1 (von cat)
cat nicht_vorhanden.txt | wc -l

Empfohlene Kombination:

#!/bin/zsh
set -euo pipefail

trap – Aufräumen bei Beendigung:

trap führt Befehle aus, wenn das Skript beendet wird (normal oder durch Fehler):

#!/bin/zsh
set -e

# Temporäre Datei erstellen
temp_file=$(mktemp)
echo "Temp-Datei: $temp_file"

# Bei Beendigung aufräumen
trap "rm -f $temp_file; echo 'Aufgeräumt'" EXIT

# Hauptlogik
echo "Arbeite..."
sleep 2
echo "Fertig"

# temp_file wird automatisch gelöscht

Verschiedene Signale abfangen:

#!/bin/zsh

cleanup() {
    echo "Räume auf..."
    # Aufräumarbeiten hier
}

trap cleanup EXIT      # Bei normalem Ende
trap cleanup SIGINT    # Bei Ctrl+C
trap cleanup SIGTERM   # Bei kill

Praktisches Beispiel:

#!/bin/zsh
set -euo pipefail

# Temporäres Verzeichnis
work_dir=$(mktemp -d)
trap "rm -rf $work_dir" EXIT

echo "Arbeitsverzeichnis: $work_dir"

# Dateien im temp-Verzeichnis verarbeiten
cd "$work_dir"
curl -O https://example.com/datei.zip
unzip datei.zip
# ... weitere Verarbeitung ...

# work_dir wird automatisch gelöscht

8.4 Profiling (time, dtruss)

time – Ausführungszeit messen:

time ./mein_skript.sh

Ausgabe:

./mein_skript.sh  0.05s user 0.02s system 89% cpu 0.078 total

Einzelne Befehle messen:

time sleep 2
time find / -name "*.log" 2>/dev/null

dtruss – Systemaufrufe verfolgen (macOS):

dtruss ist das macOS-Äquivalent zu strace unter Linux. Es zeigt alle Systemaufrufe eines Prozesses:

# Erfordert Root-Rechte
sudo dtruss ./mein_skript.sh

Nur bestimmte Syscalls:

sudo dtruss -t open ./mein_skript.sh   # Nur open()-Aufrufe
sudo dtruss -t read ./mein_skript.sh   # Nur read()-Aufrufe

Laufenden Prozess analysieren:

sudo dtruss -p <PID>

Alternative: dtrace:

Für komplexere Analysen bietet macOS dtrace:

sudo dtrace -n 'syscall:::entry /execname == "zsh"/ { @[probefunc] = count(); }'

8.5 Shebang #!/bin/zsh

Die erste Zeile eines Skripts (Shebang) bestimmt, welcher Interpreter verwendet wird:

#!/bin/zsh

Häufige Shebangs:

/usr/bin/env – Flexibler Ansatz:

#!/usr/bin/env zsh

Vorteile:

• Findet den Interpreter im $PATH
• Funktioniert auch wenn zsh nicht in /bin/zsh liegt
• Portabler zwischen verschiedenen Systemen

Wichtig:

• Der Shebang muss in der ersten Zeile stehen
• Vor #! dürfen keine Zeichen stehen (auch keine Leerzeichen)
• Die Zeile muss mit einem Zeilenumbruch enden

9 Formatierung der Ausgabe

Insbesondere beim Schreiben von Aliasen, Funktionen und Skripten kann der Einsatz Farbe und Fettmarkierungen hilfreich sein, um die Ausgabe übersichtlich zu halten.

Beispiele:

echo "\033[31mRot\033[0m"          # Rot
echo "\033[32mGrün\033[0m"         # Grün
echo "\033[1;33mFett Gelb\033[0m"  # Fetter Text
echo -e "\033[34m$(pwd)\033[0m"    # Ausgabe von `pwd` in blau

• \033[ leitet eine Escape-Sequenz ein
• 31 = Rot, 32 = Grün, 34 = Blau
• 1 = Fett
• 0m = Zurücksetzen der Formatierung

Häufig verwendete Farben:

Stile:

Erweiterte Stiltabelle:

10 Skript-Vorlage

#!/usr/bin/env zsh
set -euo pipefail

# [Short description of the script]

# --- Configuration ---
readonly SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
readonly SCRIPT_NAME="$(basename "$0")"

# --- Functions ---
show_help() {
    cat << EOF
Usage: $SCRIPT_NAME [OPTIONS] <argument>

Description of the script.

Options:
  -h, --help    Show this help

Example:
  $SCRIPT_NAME -v input.txt
EOF
}

log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" }


# --- Main program ---
main() {
    if [$]($.md#-eq-0); then
        show_help
        exit 1
    fi

    # Parse command line options
    while getopts "h:" opt; do  # Add further flags here
        case $opt in
            h)  show_help; exit 0 ;;
            \?) echo "Invalid option: -$OPTARG" >&2; exit 1 ;;
            :)  echo "Option -$OPTARG requires an argument" >&2; exit 1 ;;
        esac
    done

    log "Script started"
    # ... Main logic here ...
    log "Script finished"
}

main "$@"

Regex, sed & awk

Reguläre Ausdrücke (Regex) sind ein mächtiges Werkzeug zur Mustererkennung in Texten. In Kombination mit sed und awk ermöglichen sie komplexe Textverarbeitung direkt im Terminal.

1 Regex-Grundlagen

Reguläre Ausdrücke beschreiben Suchmuster für Text. Sie werden von vielen Tools unterstützt: grep, sed, awk, find, vim und Programmiersprachen wie Python, JavaScript und Rust.

1.1 Literale Zeichen

Die einfachste Form: Zeichen matchen sich selbst.

echo "Hallo Welt" | grep "Welt"   # Findet "Welt"
echo "Hallo Welt" | grep "xyz"    # Keine Ausgabe

1.2 Metazeichen

Metazeichen haben eine besondere Bedeutung:

Beispiele:

# Zeilen die mit "Error" beginnen
grep "^Error" logfile.txt

# Zeilen die mit ".txt" enden
grep "\.txt$" dateiliste.txt

# Beliebiges Zeichen zwischen H und llo
echo -e "Hallo\nHello\nHullo" | grep "H.llo"

1.3 Zeichenklassen

Zeichenklassen matchen eines von mehreren Zeichen:

Vordefinierte Zeichenklassen (POSIX):

Beispiele:

# Nur Zeilen mit Ziffern
grep "[0-9]" datei.txt

# Zeilen die mit Großbuchstaben beginnen
grep "^[A-Z]" datei.txt

# Wörter mit Bindestrich
grep "[a-z]-[a-z]" datei.txt

1.4 Quantifizierer

Quantifizierer bestimmen, wie oft ein Element vorkommen darf:

Beispiele:

# Telefonnummern (vereinfacht)
grep -E "[0-9]{3,5}" kontakte.txt

# Postleitzahlen (5 Ziffern)
grep -E "^[0-9]{5}$" plz.txt

# Optionaler Bindestrich
grep -E "[0-9]{4}-?[0-9]{4}" nummern.txt

1.5 Gruppen und Alternativen

Beispiele:

# "error" oder "warning" (case-insensitive)
grep -iE "(error|warning)" logfile.txt

# Wiederholte Wörter finden
grep -E "\b(\w+)\s+\1\b" text.txt

# Entweder http oder https
grep -E "https?://" urls.txt

1.6 Anker und Wortgrenzen

Beispiele:

# Nur das Wort "the" (nicht "there", "other")
grep -E "\bthe\b" text.txt

# Zeilen die nur aus Ziffern bestehen
grep -E "^[0-9]+$" datei.txt

# Leere Zeilen
grep -E "^$" datei.txt

1.7 BRE vs. ERE

Es gibt zwei Regex-Varianten:

BRE (Basic Regular Expressions):

• Standard bei grep und sed
• +, ?, |, () müssen escaped werden: \+, \?, \|, \(\)

ERE (Extended Regular Expressions):

• Bei grep -E (oder egrep) und sed -E
• +, ?, |, () funktionieren direkt

# BRE: Escaping nötig
grep "https\?" urls.txt
sed 's/\(error\|warning\)/PROBLEM/g' log.txt

# ERE: Kein Escaping
grep -E "https?" urls.txt
sed -E 's/(error|warning)/PROBLEM/g' log.txt

Empfehlung: ERE verwenden (grep -E, sed -E) für bessere Lesbarkeit.

1.8 Regex-Schnellreferenz

Zeichen:
  .         Beliebiges Zeichen
  \d        Ziffer (manche Tools)
  \w        Wortzeichen [a-zA-Z0-9_]
  \s        Whitespace

Anker:
  ^         Zeilenanfang
  $         Zeilenende
  \b        Wortgrenze

Quantifizierer:
  *         0 oder mehr
  +         1 oder mehr
  ?         0 oder 1
  {n}       Genau n
  {n,m}     n bis m

Klassen:
  [abc]     a, b oder c
  [^abc]    Nicht a, b, c
  [a-z]     Bereich a bis z

Gruppen:
  (...)     Gruppe
  |         Alternative
  \1        Rückreferenz

2 sed – Stream Editor

sed (Stream Editor) verarbeitet Text zeilenweise und führt Transformationen durch. Es ist ideal für automatisierte Ersetzungen und Textmanipulationen.

2.1 Grundsyntax

sed [OPTIONEN] 'BEFEHL' [DATEI]

Häufige Optionen:

2.2 Suchen und Ersetzen (s)

Das häufigste sed-Kommando:

sed 's/SUCHE/ERSETZUNG/FLAGS'

Flags:

Beispiele:

# Erstes Vorkommen pro Zeile
echo "hallo hallo" | sed 's/hallo/hi/'
# Ausgabe: hi hallo

# Alle Vorkommen
echo "hallo hallo" | sed 's/hallo/hi/g'
# Ausgabe: hi hi

# Case-insensitive
echo "Hallo HALLO" | sed 's/hallo/hi/gi'
# Ausgabe: hi hi

# Nur zweites Vorkommen
echo "a a a a" | sed 's/a/X/2'
# Ausgabe: a X a a

2.3 Trennzeichen

Das Trennzeichen muss nicht / sein – nützlich bei Pfaden:

# Mit /
sed 's/\/usr\/local/\/opt/g'

# Besser: Anderes Trennzeichen
sed 's|/usr/local|/opt|g'
sed 's#/usr/local#/opt#g'
sed 's@/usr/local@/opt@g'

2.4 Gruppen und Rückreferenzen

Mit \(...\) (BRE) oder (...) (ERE) können Teile erfasst und mit \1, \2 wiederverwendet werden:

# Reihenfolge tauschen
echo "Max Mustermann" | sed -E 's/([^ ]+) ([^ ]+)/\2, \1/'
# Ausgabe: Mustermann, Max

# Datum umformatieren
echo "2024-01-15" | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3.\2.\1/'
# Ausgabe: 15.01.2024

# Wörter verdoppeln
echo "test" | sed -E 's/(.+)/\1 \1/'
# Ausgabe: test test

# HTML-Tags entfernen
echo "<b>Text</b>" | sed -E 's/<[^>]+>//g'
# Ausgabe: Text

2.5 Adressierung – Zeilen auswählen

Befehle können auf bestimmte Zeilen beschränkt werden:

Beispiele:

# Nur Zeile 3 bearbeiten
sed '3s/alt/neu/' datei.txt

# Zeilen 2-5 bearbeiten
sed '2,5s/alt/neu/' datei.txt

# Letzte Zeile bearbeiten
sed '$s/alt/neu/' datei.txt

# Nur Zeilen mit "error"
sed '/error/s/status/STATUS/' log.txt

# Ab "START" bis "END"
sed '/START/,/END/s/foo/bar/g' datei.txt

2.6 Weitere sed-Befehle

Beispiele:

# Zeilen löschen
sed '3d' datei.txt              # Zeile 3 löschen
sed '/^#/d' config.txt          # Kommentare löschen
sed '/^$/d' datei.txt           # Leere Zeilen löschen

# Zeilen ausgeben (mit -n)
sed -n '5p' datei.txt           # Nur Zeile 5 ausgeben
sed -n '10,20p' datei.txt       # Zeilen 10-20
sed -n '/error/p' log.txt       # Nur Zeilen mit "error"

# Text einfügen
sed '3a\Neue Zeile' datei.txt   # Nach Zeile 3
sed '1i\Kopfzeile' datei.txt    # Vor Zeile 1

# Zeichen ersetzen (wie tr)
echo "hello" | sed 'y/aeiou/AEIOU/'
# Ausgabe: hEllO

2.7 Mehrere Befehle

# Mit -e
sed -e 's/foo/bar/' -e 's/baz/qux/' datei.txt

# Mit Semikolon
sed 's/foo/bar/; s/baz/qux/' datei.txt

# Mehrzeilig
sed '
  s/foo/bar/g
  s/baz/qux/g
  /^#/d
' datei.txt

2.8 In-place-Bearbeitung

# macOS: Leeres Backup-Suffix erforderlich
sed -i '' 's/alt/neu/g' datei.txt

# Mit Backup
sed -i '.bak' 's/alt/neu/g' datei.txt

# Linux: Kein Suffix nötig
sed -i 's/alt/neu/g' datei.txt

2.9 Praktische sed-Beispiele

# Leerzeichen am Zeilenende entfernen
sed 's/[:space:](:space:.md)*$//' datei.txt

# Mehrere Leerzeichen zu einem
sed -E 's/ +/ /g' datei.txt

# Erste Zeile jeder Datei (wie head -1)
sed -n '1p' *.txt

# Zeilen 5-10 löschen
sed '5,10d' datei.txt

# Jede Zeile nummerieren
sed = datei.txt | sed 'N; s/\n/\t/'

# Zwischen zwei Markern ersetzen
sed '/BEGIN/,/END/s/old/new/g' datei.txt

# Konfigurationswert ändern
sed -E 's/^(port=).*/\18080/' config.txt

# CSV: Spaltenreihenfolge ändern
sed -E 's/([^,]+),([^,]+),([^,]+)/\3,\1,\2/' data.csv

3 awk – Textanalyse und Berichte

awk ist eine vollständige Programmiersprache für Textverarbeitung. Es eignet sich besonders für spaltenbasierte Daten wie CSV, Logs und tabellarische Ausgaben.

3.1 Grundsyntax

awk [OPTIONEN] 'PROGRAMM' [DATEI]

Ein awk-Programm besteht aus Regeln:

MUSTER { AKTION }

• Zeilen die dem MUSTER entsprechen, führen die AKTION aus
• Ohne MUSTER: Aktion auf alle Zeilen
• Ohne AKTION: Zeile ausgeben

3.2 Felder und Variablen

awk teilt jede Zeile automatisch in Felder:

Beispiele:

# Erste Spalte ausgeben
echo "Max 30 Berlin" | awk '{print $1}'
# Ausgabe: Max

# Mehrere Spalten
echo "Max 30 Berlin" | awk '{print $1, $3}'
# Ausgabe: Max Berlin

# Spalten in anderer Reihenfolge
echo "Max 30 Berlin" | awk '{print $3, $1, $2}'
# Ausgabe: Berlin Max 30

# Letzte Spalte
echo "a b c d e" | awk '{print $NF}'
# Ausgabe: e

# Anzahl Felder
echo "a b c d e" | awk '{print NF}'
# Ausgabe: 5

3.3 Feldtrenner ändern

# Mit -F
awk -F',' '{print $1}' datei.csv
awk -F':' '{print $1, $3}' /etc/passwd

# Im Programm
awk 'BEGIN{FS=","} {print $1}' datei.csv

# Mehrere Trennzeichen
awk -F'[,;:]' '{print $1}' datei.txt

# Tab als Trenner
awk -F'\t' '{print $2}' datei.tsv

3.4 Muster (Pattern)

# Zeilen mit "error"
awk '/error/' log.txt

# Zeilen die NICHT "comment" enthalten
awk '!/comment/' datei.txt

# Zeilen wo Feld 3 größer als 100
awk '$3 > 100' daten.txt

# Zeilen wo Feld 1 einem Muster entspricht
awk '$1 ~ /^A/' namen.txt

# Kombination
awk '/error/ && $3 > 5' log.txt

# Bereichsmuster
awk '/START/,/END/' datei.txt

3.5 BEGIN und END

BEGIN wird vor der ersten Zeile ausgeführt, END nach der letzten:

# Kopfzeile ausgeben
awk 'BEGIN{print "Name\tAlter"} {print $1, $2}' daten.txt

# Summe berechnen
awk '{sum += $1} END{print "Summe:", sum}' zahlen.txt

# Zeilen zählen
awk 'END{print NR, "Zeilen"}' datei.txt

# Durchschnitt berechnen
awk '{sum += $1; count++} END{print "Durchschnitt:", sum/count}' zahlen.txt

3.6 Formatierte Ausgabe mit printf

# Grundsyntax
awk '{printf "%-10s %5d\n", $1, $2}' daten.txt

Format-Spezifizierer:

Beispiele:

# Tabelle formatieren
awk '{printf "%-15s %8.2f\n", $1, $2}' preise.txt

# Mit Kopfzeile
awk 'BEGIN{printf "%-15s %8s\n", "Produkt", "Preis"; print "------------------------"}
     {printf "%-15s %8.2f\n", $1, $2}' preise.txt

3.7 Variablen und Berechnungen

# Eigene Variablen
awk '{total = $2 * $3; print $1, total}' bestellung.txt

# Externe Variablen übergeben
threshold=100
awk -v limit="$threshold" '$2 > limit {print}' daten.txt

# Mehrere Variablen
awk -v min=10 -v max=50 '$1 >= min && $1 <= max' zahlen.txt

3.8 Kontrollstrukturen

if-else:

awk '{
    if ($3 > 100)
        print $1, "hoch"
    else if ($3 > 50)
        print $1, "mittel"
    else
        print $1, "niedrig"
}' daten.txt

for-Schleife:

# Alle Felder ausgeben
awk '{for(i=1; i<=NF; i++) print i, $i}' datei.txt

# Felder rückwärts
awk '{for(i=NF; i>=1; i--) printf "%s ", $i; print ""}' datei.txt

while-Schleife:

awk '{
    i = 1
    while(i <= NF) {
        print $i
        i++
    }
}' datei.txt

3.9 Arrays

# Werte zählen
awk '{count[$1]++} END{for(key in count) print key, count[key]}' log.txt

# Summen nach Kategorie
awk '{sum[$1] += $2} END{for(cat in sum) print cat, sum[cat]}' verkauf.txt

# Duplikate finden
awk 'seen[$0]++' datei.txt

# Einzigartige Zeilen (wie uniq)
awk '!seen[$0]++' datei.txt

3.10 Eingebaute Funktionen

String-Funktionen:

Beispiele:

# Stringlänge
echo "Hallo Welt" | awk '{print length($0)}'
# Ausgabe: 10

# Substring
echo "Hallo Welt" | awk '{print substr($0, 1, 5)}'
# Ausgabe: Hallo

# Ersetzen
echo "foo bar foo" | awk '{gsub(/foo/, "baz"); print}'
# Ausgabe: baz bar baz

# Großbuchstaben
echo "hallo" | awk '{print toupper($0)}'
# Ausgabe: HALLO

Mathematische Funktionen:

3.11 Praktische awk-Beispiele

# CSV: Bestimmte Spalten extrahieren
awk -F',' '{print $1, $3}' data.csv

# Summe einer Spalte
awk '{sum += $2} END{print sum}' zahlen.txt

# Durchschnitt
awk '{sum += $1; n++} END{print sum/n}' zahlen.txt

# Maximum finden
awk 'BEGIN{max=0} $1>max{max=$1} END{print max}' zahlen.txt

# Zeilen mit mehr als 3 Feldern
awk 'NF > 3' datei.txt

# Jede zweite Zeile
awk 'NR % 2 == 0' datei.txt

# Zeilen zwischen zwei Markern (ohne Marker)
awk '/START/{flag=1; next} /END/{flag=0} flag' datei.txt

# IP-Adressen extrahieren aus Log
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head

# Dateigröße pro Verzeichnis
ls -l | awk '/^-/{sum += $5} END{print "Total:", sum, "Bytes"}'

# Spalten vertauschen
awk '{print $2, $1, $3}' datei.txt

# Bestimmte Zeilen und Spalten
awk 'NR >= 5 && NR <= 10 {print $1, $3}' datei.txt

# Feldtrenner für Ausgabe setzen
awk 'BEGIN{OFS=","} {print $1, $2, $3}' datei.txt

# Top 10 häufigste Werte
awk '{print $1}' datei.txt | sort | uniq -c | sort -rn | head -10

4 Kombinationsbeispiele (Pipe-Workflows)

Die wahre Stärke von sed, awk und Regex zeigt sich in Kombination mit anderen Unix-Tools.

4.1 Log-Analyse

Fehler aus Log extrahieren und zählen:

grep -i "error" application.log | \
    awk '{print $4}' | \
    sort | uniq -c | sort -rn | head -10

Zugriffe pro Stunde aus Access-Log:

awk '{print $4}' access.log | \
    cut -d: -f2 | \
    sort | uniq -c | \
    awk '{print $2":00", $1}'

IP-Adressen mit den meisten Fehlern:

grep " 404 \| 500 " access.log | \
    awk '{print $1}' | \
    sort | uniq -c | sort -rn | head -10

Langsame Requests finden (> 5 Sekunden):

awk '$NF > 5000 {print $7, $NF"ms"}' access.log | \
    sort -t' ' -k2 -rn | head -20

4.2 Dateitransformationen

CSV zu TSV konvertieren:

sed 's/,/\t/g' data.csv > data.tsv

JSON-Lines zu CSV (einfach):

cat data.jsonl | \
    sed 's/[{}":]//g' | \
    sed 's/,/\t/g'

Konfigurationsdatei bereinigen:

# Kommentare und leere Zeilen entfernen, sortieren
grep -v '^#' config.txt | \
    grep -v '^$' | \
    sed 's/[:space:](:space:.md)*$//' | \
    sort

Markdown-Überschriften extrahieren:

grep -E "^#{1,3} " document.md | \
    sed 's/^#* //' | \
    awk '{printf "%d. %s\n", NR, $0}'

4.3 System-Administration

Disk-Usage sortiert nach Größe:

du -sh * 2>/dev/null | \
    sort -rh | head -20

Größte Dateien finden:

find . -type f -exec ls -la {} \; 2>/dev/null | \
    awk '{print $5, $9}' | \
    sort -rn | head -20

Prozesse nach Memory-Verbrauch:

ps aux | \
    awk 'NR>1 {print $4, $11}' | \
    sort -rn | head -10

Offene Ports auflisten:

netstat -an | \
    grep LISTEN | \
    awk '{print $4}' | \
    sed 's/.*\.//' | \
    sort -n | uniq

4.4 Textbereinigung

Mehrfache Leerzeichen und -zeilen bereinigen:

cat messy.txt | \
    sed 's/[:space:](:space:.md)\+/ /g' | \
    sed 's/^[:space:](:space:.md)//' | \
    sed 's/[:space:](:space:.md)$//' | \
    cat -s

HTML-Tags entfernen:

sed -E 's/<[^>]+>//g' page.html | \
    sed '/^$/d' | \
    sed 's/&nbsp;/ /g; s/&amp;/\&/g; s/&lt;/</g; s/&gt;/>/g'

E-Mail-Adressen extrahieren:

grep -oE '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}' dokument.txt | \
    sort -u

URLs extrahieren:

grep -oE 'https?://[^[:space:]"<>]+' webpage.html | \
    sort -u

4.5 Datenanalyse

CSV-Statistiken:

# Spalte 3: Min, Max, Durchschnitt
awk -F',' 'NR>1 {
    sum += $3; count++;
    if(min == "" || $3 < min) min = $3;
    if(max == "" || $3 > max) max = $3
} END {
    print "Min:", min
    print "Max:", max
    print "Avg:", sum/count
}' data.csv

Häufigkeit von Werten in Spalte:

awk -F',' 'NR>1 {count[$2]++} END {
    for(val in count) print count[val], val
}' data.csv | sort -rn

Gruppierte Summen:

awk -F',' 'NR>1 {sum[$1] += $3} END {
    for(group in sum) print group, sum[group]
}' sales.csv | sort -t' ' -k2 -rn

4.6 Batch-Umbenennung

Dateinamen bereinigen (Leerzeichen durch Unterstriche):

for f in *\ *; do
    mv "$f" "$(echo $f | sed 's/ /_/g')"
done

Dateien mit Datum versehen:

for f in *.txt; do
    mv "$f" "$(date +%Y%m%d)_$f"
done

Erweiterung ändern:

for f in *.jpeg; do
    mv "$f" "${f%.jpeg}.jpg"
done

# Oder mit sed
ls *.jpeg | sed 's/\(.*\)\.jpeg/mv "\1.jpeg" "\1.jpg"/' | sh

4.7 Komplexe Pipeline-Beispiele

Git: Änderungen pro Autor (letzte 30 Tage):

git log --since="30 days ago" --format='%an' | \
    sort | uniq -c | sort -rn

Apache-Log: Requests pro Minute visualisieren:

awk '{print $4}' access.log | \
    cut -d: -f1-3 | \
    uniq -c | \
    awk '{printf "%s %s\n", $2, substr("====================", 1, $1/10)}'

Wort-Frequenz-Analyse:

cat text.txt | \
    tr '[:upper:]' '[:lower:]' | \
    tr -cs '[:alpha:]' '\n' | \
    sort | uniq -c | sort -rn | head -20

JSON-Werte aggregieren (mit jq und awk):

cat data.json | \
    jq -r '.[] | "\(.category) \(.amount)"' | \
    awk '{sum[$1] += $2} END {for(c in sum) print c, sum[c]}' | \
    sort -k2 -rn

4.8 Debugging von Pipelines

Schritt-für-Schritt testen:

# Erst einzeln testen
cat log.txt | head
cat log.txt | grep "error" | head
cat log.txt | grep "error" | awk '{print $1}' | head
# ... dann erweitern

Zwischenergebnisse mit tee:

cat data.txt | \
    tee /dev/stderr | \     # Zeigt Zwischenergebnis
    grep "pattern" | \
    tee step1.txt | \       # Speichert Zwischenergebnis
    awk '{print $2}'

Pipeline mit Zeilennummern debuggen:

cat -n datei.txt | grep "muster"

Cronjobs & launchd

Automatisierte Aufgaben sind essentiell für Systemadministration, Backups, Wartung und wiederkehrende Prozesse. Unter macOS gibt es zwei Systeme: das klassische Unix-Tool cron und Apples eigenes launchd.

1 Cron-Grundlagen

cron ist der klassische Unix-Dienst für zeitgesteuerte Aufgaben. Er stammt aus den 1970er Jahren und ist auf praktisch jedem Unix/Linux-System verfügbar.

1.1 Wie cron funktioniert

• Der cron-Daemon läuft im Hintergrund
• Er prüft jede Minute, ob geplante Aufgaben anstehen
• Aufgaben werden in Crontabs (cron tables) definiert
• Jeder Benutzer kann eine eigene Crontab haben

1.2 Crontab verwalten

Erste Verwendung:

crontab -e

Dies öffnet den Standard-Editor (meist vim oder nano). Um den Editor zu ändern:

export EDITOR=nano
crontab -e

1.3 Speicherorte

2 Cron-Syntax & Beispiele

2.1 Grundsyntax

Eine Crontab-Zeile hat folgendes Format:

┌───────────── Minute (0-59)
│ ┌───────────── Stunde (0-23)
│ │ ┌───────────── Tag des Monats (1-31)
│ │ │ ┌───────────── Monat (1-12)
│ │ │ │ ┌───────────── Wochentag (0-7, 0 und 7 = Sonntag)
│ │ │ │ │
* * * * * Befehl

2.2 Sonderzeichen

2.3 Beispiele

Zeitangaben:

Vollständige Crontab-Beispiele:

# Backup jeden Tag um 2:00 Uhr
0 2 * * * /Users/max/scripts/backup.sh

# Log-Rotation jeden Sonntag um 3:00 Uhr
0 3 * * 0 /Users/max/scripts/rotate-logs.sh

# Alle 5 Minuten: System-Check
*/5 * * * * /Users/max/scripts/health-check.sh

# Werktags um 9:00: Bericht generieren
0 9 * * 1-5 /Users/max/scripts/daily-report.sh

# Am 1. und 15. jeden Monats
0 0 1,15 * * /Users/max/scripts/bi-monthly.sh

# Nur im Januar, täglich um 6:00
0 6 * 1 * /Users/max/scripts/january-task.sh

2.4 Spezielle Strings

Einige cron-Implementierungen unterstützen lesbare Kürzel:

@daily /Users/max/scripts/backup.sh
@reboot /Users/max/scripts/startup.sh

macOS-Kompatibilität:

macOS verwendet Vixie cron (BSD-basiert). Die Unterstützung der speziellen Strings:

Problem mit @reboot: Unter macOS startet der cron-Daemon erst nach dem Benutzer-Login, nicht beim Systemstart. Jobs mit @reboot werden daher nicht ausgeführt oder nur beim ersten Login nach einem Neustart.

Lösung für Startup-Tasks: Verwende stattdessen launchd mit RunAtLoad:

<key>RunAtLoad</key>
<true/>

Siehe [[#4 Erstellung von .plist-Jobs|Erstellung von .plist-Jobs]] für Details.

2.5 Umgebungsvariablen

Cron führt Befehle mit einer minimalen Umgebung aus. Wichtige Variablen sollten definiert werden:

# Umgebungsvariablen setzen
SHELL=/bin/zsh
PATH=/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin
HOME=/Users/max
MAILTO=max@example.com

# Jobs
0 * * * * /Users/max/scripts/task.sh

Wichtig: Der PATH in cron ist sehr eingeschränkt. Entweder:

1. Vollständige Pfade zu Programmen verwenden
2. PATH in der Crontab setzen
3. PATH im Skript selbst setzen

#!/bin/zsh
# Am Anfang des Skripts:
export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"

2.6 Ausgabe und Logging

Standardmäßig wird die Ausgabe per E-Mail gesendet (falls konfiguriert). Alternativen:

# Ausgabe in Datei
0 * * * * /script.sh >> /var/log/script.log 2>&1

# Ausgabe verwerfen
0 * * * * /script.sh > /dev/null 2>&1

# Nur Fehler loggen
0 * * * * /script.sh >> /var/log/script.log 2>&1

# Mit Zeitstempel
0 * * * * /script.sh 2>&1 | while read line; do echo "$(date): $line"; done >> /var/log/script.log

Logging-Wrapper-Skript:

#!/bin/zsh
# /Users/max/scripts/run-with-log.sh

LOGFILE="/var/log/cron-jobs.log"
SCRIPT="$1"
shift

echo "=== $(date '+%Y-%m-%d %H:%M:%S') - Start: $SCRIPT ===" >> "$LOGFILE"
"$SCRIPT" "$@" >> "$LOGFILE" 2>&1
EXIT_CODE=$?
echo "=== $(date '+%Y-%m-%d %H:%M:%S') - Ende: $SCRIPT (Exit: $EXIT_CODE) ===" >> "$LOGFILE"
echo "" >> "$LOGFILE"

Verwendung in Crontab:

0 * * * * /Users/max/scripts/run-with-log.sh /Users/max/scripts/task.sh

2.7 Häufige Probleme

1. Skript läuft nicht:

# Skript ausführbar machen
chmod +x /Users/max/scripts/script.sh

# Shebang prüfen
head -1 /Users/max/scripts/script.sh
# Sollte sein: #!/bin/zsh oder #!/bin/bash

2. Befehl nicht gefunden:

# FALSCH: brew ist nicht im PATH
0 * * * * brew update

# RICHTIG: Vollständiger Pfad
0 * * * * /opt/homebrew/bin/brew update

3. Berechtigungsprobleme:

# cron-Logs prüfen (macOS)
log show --predicate 'subsystem == "com.apple.cron"' --last 1h

3 launchd unter macOS

launchd ist Apples Init-System und Dienst-Manager. Es ist leistungsfähiger als cron und der empfohlene Weg für geplante Aufgaben unter macOS.

3.1 Konzepte

Agents vs. Daemons:

Für die meisten Benutzeraufgaben: ~/Library/LaunchAgents/

3.2 launchctl – Das Verwaltungstool

Moderne Syntax (ab macOS 10.10):

# Benutzer-Agent laden
launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.user.task.plist

# Benutzer-Agent entladen
launchctl bootout gui/$(id -u)/com.user.task

# System-Daemon laden (als root)
sudo launchctl bootstrap system /Library/LaunchDaemons/com.company.daemon.plist

3.3 Job-Status prüfen

# Alle Jobs auflisten
launchctl list

# Bestimmten Job finden
launchctl list | grep -i backup

# Job-Details anzeigen (moderne Syntax)
launchctl print gui/$(id -u)/com.user.backup

# Fehler prüfen
launchctl error <error_code>

4 Erstellung von .plist-Jobs

Property List (.plist) Dateien definieren launchd-Jobs im XML-Format.

4.1 Grundstruktur

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.benutzername.jobname</string>

    <key>ProgramArguments</key>
    <array>
        <string>/pfad/zum/skript.sh</string>
    </array>

    <!-- Zeitplan oder Auslöser hier -->

</dict>
</plist>

4.2 Wichtige Schlüssel

Identifikation:

Zeitsteuerung:

Auslöser:

Umgebung:

Ausgabe:

Verhalten:

4.3 StartCalendarInterval

Ähnlich wie cron-Syntax, aber als Dictionary:

Beispiele:

<!-- Täglich um 6:30 -->
<key>StartCalendarInterval</key>
<dict>
    <key>Hour</key>
    <integer>6</integer>
    <key>Minute</key>
    <integer>30</integer>
</dict>

<!-- Jeden Montag um 9:00 -->
<key>StartCalendarInterval</key>
<dict>
    <key>Weekday</key>
    <integer>1</integer>
    <key>Hour</key>
    <integer>9</integer>
    <key>Minute</key>
    <integer>0</integer>
</dict>

<!-- Mehrere Zeitpunkte (Array) -->
<key>StartCalendarInterval</key>
<array>
    <dict>
        <key>Hour</key>
        <integer>9</integer>
        <key>Minute</key>
        <integer>0</integer>
    </dict>
    <dict>
        <key>Hour</key>
        <integer>17</integer>
        <key>Minute</key>
        <integer>0</integer>
    </dict>
</array>

4.4 Vollständige Beispiele

Beispiel 1: Tägliches Backup um 2:00 Uhr

Datei: ~/Library/LaunchAgents/com.user.backup.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.backup</string>

    <key>ProgramArguments</key>
    <array>
        <string>/Users/max/scripts/backup.sh</string>
    </array>

    <key>StartCalendarInterval</key>
    <dict>
        <key>Hour</key>
        <integer>2</integer>
        <key>Minute</key>
        <integer>0</integer>
    </dict>

    <key>StandardOutPath</key>
    <string>/Users/max/logs/backup.log</string>

    <key>StandardErrorPath</key>
    <string>/Users/max/logs/backup-error.log</string>

    <key>WorkingDirectory</key>
    <string>/Users/max</string>

    <key>EnvironmentVariables</key>
    <dict>
        <key>PATH</key>
        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
    </dict>
</dict>
</plist>

Beispiel 2: Alle 30 Minuten ausführen

Datei: ~/Library/LaunchAgents/com.user.sync.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.sync</string>

    <key>ProgramArguments</key>
    <array>
        <string>/Users/max/scripts/sync.sh</string>
    </array>

    <key>StartInterval</key>
    <integer>1800</integer>  <!-- 30 Minuten = 1800 Sekunden -->

    <key>RunAtLoad</key>
    <true/>

    <key>StandardOutPath</key>
    <string>/Users/max/logs/sync.log</string>

    <key>StandardErrorPath</key>
    <string>/Users/max/logs/sync.log</string>
</dict>
</plist>

Beispiel 3: Bei Dateiänderung ausführen (WatchPaths)

Datei: ~/Library/LaunchAgents/com.user.watcher.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.watcher</string>

    <key>ProgramArguments</key>
    <array>
        <string>/Users/max/scripts/process-downloads.sh</string>
    </array>

    <key>WatchPaths</key>
    <array>
        <string>/Users/max/Downloads</string>
    </array>

    <key>StandardOutPath</key>
    <string>/Users/max/logs/watcher.log</string>

    <key>StandardErrorPath</key>
    <string>/Users/max/logs/watcher.log</string>
</dict>
</plist>

Beispiel 4: Bei Login ausführen

Datei: ~/Library/LaunchAgents/com.user.startup.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.startup</string>

    <key>ProgramArguments</key>
    <array>
        <string>/Users/max/scripts/startup.sh</string>
    </array>

    <key>RunAtLoad</key>
    <true/>
</dict>
</plist>

Beispiel 5: Dienst dauerhaft laufen lassen (KeepAlive)

Datei: ~/Library/LaunchAgents/com.user.server.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.server</string>

    <key>ProgramArguments</key>
    <array>
        <string>/Users/max/scripts/server.sh</string>
    </array>

    <key>RunAtLoad</key>
    <true/>

    <key>KeepAlive</key>
    <true/>

    <key>ThrottleInterval</key>
    <integer>10</integer>

    <key>StandardOutPath</key>
    <string>/Users/max/logs/server.log</string>

    <key>StandardErrorPath</key>
    <string>/Users/max/logs/server.log</string>
</dict>
</plist>

4.5 Job aktivieren

# 1. Datei erstellen/bearbeiten
nano ~/Library/LaunchAgents/com.user.backup.plist

# 2. Syntax prüfen
plutil -lint ~/Library/LaunchAgents/com.user.backup.plist

# 3. Job laden
launchctl load ~/Library/LaunchAgents/com.user.backup.plist

# 4. Prüfen ob geladen
launchctl list | grep com.user.backup

# 5. Manuell testen
launchctl start com.user.backup

4.6 Job deaktivieren

# Job entladen
launchctl unload ~/Library/LaunchAgents/com.user.backup.plist

# Job deaktivieren (bleibt entladen nach Neustart)
launchctl unload -w ~/Library/LaunchAgents/com.user.backup.plist

# Oder: Disabled-Key in plist setzen

4.7 Fehlersuche

# plist-Syntax prüfen
plutil -lint ~/Library/LaunchAgents/com.user.task.plist

# Geladene Jobs anzeigen
launchctl list | grep com.user

# Exit-Status prüfen (0 = OK, sonst Fehler)
launchctl list | grep com.user.task
# Ausgabe: PID  Status  Label
#          -    0       com.user.task  (Status 0 = OK)
#          -    1       com.user.task  (Status 1 = Fehler)

# System-Log prüfen
log show --predicate 'subsystem == "com.apple.xpc.launchd"' --last 1h | grep com.user

# Ausgabe-Logs prüfen
tail -f ~/logs/task.log

Häufige Fehler:

5 Unterschiede Cron vs. launchd

5.1 Vergleichstabelle

5.2 Wann cron verwenden?

✅ cron ist besser für:

• Einfache, zeitbasierte Aufgaben
• Portabilität (Skripte auch auf Linux nutzbar)
• Schnelle, unkomplizierte Einrichtung
• Erfahrene Unix-Nutzer

Beispiel-Anwendungsfälle:

# Einfaches tägliches Backup
0 2 * * * /Users/max/scripts/backup.sh

# Stündlicher Check
0 * * * * /Users/max/scripts/check.sh

5.3 Wann launchd verwenden?

✅ launchd ist besser für:

• macOS-spezifische Aufgaben
• Reaktion auf Ereignisse (Dateiänderungen, Netzwerk)
• Dienste die dauerhaft laufen sollen
• Bessere Fehlerbehandlung
• Integration mit macOS-Funktionen (Power Management, etc.)
• Wenn verpasste Jobs nachgeholt werden sollen

Beispiel-Anwendungsfälle:

• Ordner überwachen und bei Änderung reagieren
• Dienst der nach Absturz neu startet
• Task der nur bei Netzwerkverbindung läuft

5.4 Entscheidungshilfe

Aufgabe                                 → Wahl
────────────────────────────────────────────────
Einfache Zeitsteuerung                 → cron
Reaktion auf Dateiänderungen           → launchd
Dauerlaufenden Dienst                  → launchd
Portabilität zu Linux                  → cron
Nachholung verpasster Jobs             → launchd
Schnelle Einrichtung                   → cron
macOS-Integration (Sleep/Wake)         → launchd
Komplexe Bedingungen                   → launchd

5.5 Migration cron → launchd

cron:

30 2 * * * /Users/max/scripts/backup.sh

Äquivalentes launchd:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.backup</string>

    <key>ProgramArguments</key>
    <array>
        <string>/Users/max/scripts/backup.sh</string>
    </array>

    <key>StartCalendarInterval</key>
    <dict>
        <key>Hour</key>
        <integer>2</integer>
        <key>Minute</key>
        <integer>30</integer>
    </dict>
</dict>
</plist>

5.6 Beide parallel nutzen

Es ist möglich, beide Systeme gleichzeitig zu verwenden:

• cron für einfache, portable Aufgaben
• launchd für macOS-spezifische Anforderungen

Tipp: Dokumentieren, welche Aufgaben wo konfiguriert sind:

# Alle aktiven Jobs anzeigen
echo "=== Cron Jobs ==="
crontab -l

echo ""
echo "=== LaunchAgents ==="
ls ~/Library/LaunchAgents/

echo ""
echo "=== Geladene Jobs ==="
launchctl list | grep com.user

5.7 Empfehlung

Für neue macOS-Projekte wird launchd empfohlen:

1. Bessere Integration ins System
2. Mehr Flexibilität bei Auslösern
3. Zuverlässigere Ausführung
4. Bessere Logging-Möglichkeiten
5. Von Apple unterstützt und gepflegt

cron bleibt eine gute Wahl für:

1. Einfache, zeitbasierte Tasks
2. Cross-Platform-Kompatibilität
3. Schnelle Einrichtung ohne XML

tmux & screen

Terminal-Multiplexer ermöglichen mehrere Terminal-Sitzungen in einem Fenster. Sie sind unverzichtbar für Remote-Arbeit, da Sessions auch nach Verbindungsabbruch weiterlaufen.

1 tmux Grundlagen

tmux (Terminal Multiplexer) ist der moderne Standard für Terminal-Multiplexing. Es ist leistungsfähiger und aktiver entwickelt als das ältere screen.

1.1 Installation

# macOS (Homebrew)
brew install tmux

# Version prüfen
tmux -V

1.2 Konzepte

tmux organisiert sich in drei Ebenen:

Server
  └── Session (benannte Sitzung)
        └── Window (Tab/Fenster)
              └── Pane (geteilter Bereich)

1.3 Erste Schritte

# Neue Session starten
tmux

# Neue benannte Session
tmux new -s arbeit

# Session verlassen (läuft weiter)
# Prefix + d  (Ctrl+b, dann d)

# Sessions auflisten
tmux ls

# Zu Session verbinden
tmux attach -t arbeit
tmux a -t arbeit          # Kurzform

# Letzte Session
tmux attach
tmux a

1.4 Prefix-Taste

Alle tmux-Befehle beginnen mit dem Prefix (Standard: Ctrl+b), gefolgt von einer Taste.

Ctrl+b, dann Befehlstaste

Beispiel: Um ein neues Fenster zu erstellen: Ctrl+b, loslassen, dann c.

Notation in dieser Referenz:

• Prefix + x bedeutet: Ctrl+b drücken, loslassen, dann x drücken
• Prefix kann in der Konfiguration geändert werden (oft zu Ctrl+a)

2 Fenster, Panes, Sessions

2.1 Session-Befehle

Tastenkürzel (innerhalb tmux):

Kommandozeile:

# Neue Session
tmux new -s name

# Mit bestimmtem Startverzeichnis
tmux new -s projekt -c ~/projekte/webapp

# Session beenden
tmux kill-session -t name

# Alle Sessions beenden
tmux kill-server

# Session umbenennen
tmux rename-session -t alt neu

2.2 Window-Befehle (Fenster)

Windows sind wie Tabs innerhalb einer Session.

Tastenkürzel:

Kommandozeile:

# Neues Window in bestehender Session
tmux new-window -t session:

# Window mit Name
tmux new-window -t session: -n "logs"

# Window schließen
tmux kill-window -t session:2

2.3 Pane-Befehle (Bereiche)

Panes teilen ein Window in mehrere Bereiche.

Tastenkürzel:

Pane-Größe ändern:

Oder im Command-Mode (Prefix + :):

resize-pane -D 10    # 10 Zeilen nach unten
resize-pane -U 5     # 5 Zeilen nach oben
resize-pane -L 10    # 10 Spalten nach links
resize-pane -R 10    # 10 Spalten nach rechts

2.4 Layouts

tmux bietet vordefinierte Layouts:

# Layout wählen
Prefix + Space              # Durch Layouts rotieren
Prefix + Alt+1              # even-horizontal
Prefix + Alt+2              # even-vertical
Prefix + Alt+3              # main-horizontal
Prefix + Alt+4              # main-vertical
Prefix + Alt+5              # tiled

2.5 Copy-Mode

Der Copy-Mode ermöglicht Scrollen und Textauswahl.

Mit vi-Modus (empfohlen):

# In ~/.tmux.conf
setw -g mode-keys vi

# Dann im Copy-Mode:
# v     = Auswahl starten
# y     = Kopieren
# V     = Zeilenweise auswählen

2.6 Command-Mode

Der Command-Mode erlaubt tmux-Befehle direkt einzugeben:

Prefix + :

Nützliche Befehle:

:new-session -s name           # Neue Session
:kill-session                  # Aktuelle Session beenden
:source ~/.tmux.conf           # Konfiguration neu laden
:list-keys                     # Alle Tastenkürzel anzeigen
:set -g option value           # Option setzen
:setw -g option value          # Window-Option setzen

3 Konfiguration

Die tmux-Konfiguration liegt in ~/.tmux.conf.

3.1 Grundlegende Einstellungen

# ~/.tmux.conf

# Prefix ändern (Ctrl+a statt Ctrl+b)
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# Schnelleres Escape (wichtig für vim)
set -sg escape-time 0

# History vergrößern
set -g history-limit 50000

# Nummerierung bei 1 beginnen
set -g base-index 1
setw -g pane-base-index 1

# Automatisch umnummerieren
set -g renumber-windows on

# Terminal-Farben
set -g default-terminal "screen-256color"
set -ga terminal-overrides ",xterm-256color:Tc"

# Maus aktivieren
set -g mouse on

# Vi-Modus für Copy-Mode
setw -g mode-keys vi

# Focus-Events (für vim etc.)
set -g focus-events on

3.2 Tastenkürzel anpassen

# Intuitivere Split-Befehle
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"
unbind '"'
unbind %

# Neues Window im aktuellen Pfad
bind c new-window -c "#{pane_current_path}"

# Pane-Navigation mit Alt+Pfeiltasten (ohne Prefix)
bind -n M-Left select-pane -L
bind -n M-Right select-pane -R
bind -n M-Up select-pane -U
bind -n M-Down select-pane -D

# Window-Navigation mit Shift+Pfeiltasten
bind -n S-Left previous-window
bind -n S-Right next-window

# Konfiguration neu laden
bind r source-file ~/.tmux.conf \; display "Config reloaded!"

# Panes synchronisieren (gleiche Eingabe in alle Panes)
bind S setw synchronize-panes

3.3 Statusleiste anpassen

# Statusleiste aktivieren
set -g status on

# Position
set -g status-position bottom

# Update-Intervall (Sekunden)
set -g status-interval 5

# Farben
set -g status-style 'bg=#333333 fg=#ffffff'

# Links: Session-Name
set -g status-left '#[fg=#000000,bg=#ffffff] #S #[default] '
set -g status-left-length 30

# Rechts: Datum und Uhrzeit
set -g status-right '#[fg=#ffffff] %Y-%m-%d %H:%M '
set -g status-right-length 50

# Window-Liste
set -g status-justify left

# Aktives Window hervorheben
setw -g window-status-current-style 'fg=#000000 bg=#00ff00 bold'
setw -g window-status-current-format ' #I:#W#F '

# Inaktive Windows
setw -g window-status-style 'fg=#888888'
setw -g window-status-format ' #I:#W#F '

3.4 Pane-Darstellung

# Aktiver Pane-Rahmen
set -g pane-active-border-style 'fg=#00ff00'

# Inaktiver Pane-Rahmen
set -g pane-border-style 'fg=#555555'

# Pane-Nummern-Anzeige
set -g display-panes-time 2000
set -g display-panes-colour '#555555'
set -g display-panes-active-colour '#00ff00'

3.5 Vollständige Beispielkonfiguration

# ~/.tmux.conf - Empfohlene Konfiguration

# === Grundeinstellungen ===
set -g prefix C-a                    # Prefix: Ctrl+a
unbind C-b
bind C-a send-prefix

set -sg escape-time 0                # Kein Delay nach Escape
set -g history-limit 50000           # Große History
set -g base-index 1                  # Windows ab 1 nummerieren
setw -g pane-base-index 1            # Panes ab 1 nummerieren
set -g renumber-windows on           # Automatisch umnummerieren
set -g mouse on                      # Maus aktivieren
setw -g mode-keys vi                 # Vi-Modus
set -g focus-events on               # Focus-Events

# === Terminal ===
set -g default-terminal "screen-256color"
set -ga terminal-overrides ",*256col*:Tc"

# === Tastenkürzel ===
# Splits (im aktuellen Verzeichnis)
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"
bind c new-window -c "#{pane_current_path}"

# Pane-Navigation (Alt+Pfeiltasten)
bind -n M-Left select-pane -L
bind -n M-Right select-pane -R
bind -n M-Up select-pane -U
bind -n M-Down select-pane -D

# Pane-Größe (Prefix + Shift+Pfeiltasten)
bind -r H resize-pane -L 5
bind -r J resize-pane -D 5
bind -r K resize-pane -U 5
bind -r L resize-pane -R 5

# Window-Navigation
bind -n S-Left previous-window
bind -n S-Right next-window

# Reload
bind r source-file ~/.tmux.conf \; display "Reloaded!"

# Copy-Mode (vi-style)
bind -T copy-mode-vi v send-keys -X begin-selection
bind -T copy-mode-vi y send-keys -X copy-selection-and-cancel
bind -T copy-mode-vi r send-keys -X rectangle-toggle

# macOS Clipboard
bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "pbcopy"

# === Statusleiste ===
set -g status on
set -g status-position bottom
set -g status-interval 5
set -g status-style 'bg=#1a1a1a fg=#808080'

set -g status-left '#[fg=#1a1a1a,bg=#87d700,bold] #S #[default] '
set -g status-left-length 30

set -g status-right '#[fg=#808080] %d.%m.%Y #[fg=#c0c0c0]%H:%M '
set -g status-right-length 50

setw -g window-status-format ' #I:#W '
setw -g window-status-current-format '#[fg=#1a1a1a,bg=#87d700,bold] #I:#W '

# === Panes ===
set -g pane-border-style 'fg=#404040'
set -g pane-active-border-style 'fg=#87d700'

# === Messages ===
set -g message-style 'bg=#87d700 fg=#1a1a1a bold'
set -g display-time 2000

3.6 Konfiguration neu laden

# Innerhalb tmux
Prefix + :
source ~/.tmux.conf

# Oder mit Tastenkürzel (wenn konfiguriert)
Prefix + r

# Von außerhalb
tmux source-file ~/.tmux.conf

4 screen-Vergleich

screen ist der ältere Terminal-Multiplexer (seit 1987). Es ist auf vielen Systemen vorinstalliert.

4.1 screen Grundlagen

# Neue Session
screen

# Benannte Session
screen -S arbeit

# Session verlassen (detach)
Ctrl+a, dann d

# Sessions auflisten
screen -ls

# Wieder verbinden
screen -r arbeit

# Verbinden (auch wenn attached)
screen -x arbeit

4.2 screen-Befehle

4.3 screen-Konfiguration

Die Konfiguration liegt in ~/.screenrc:

# ~/.screenrc

# Startmeldung deaktivieren
startup_message off

# Scrollback-Buffer
defscrollback 10000

# Visual Bell statt Audio
vbell on

# Statusleiste
hardstatus alwayslastline
hardstatus string '%{= kG}[ %{G}%H %{g}][%= %{= kw}%?%-Lw%?%{r}(%{W}%n*%f%t%?(%u)%?%{r})%{w}%?%+Lw%?%?%= %{g}][%{B} %m-%d %{W}%c %{g}]'

# Shell
shell -$SHELL

4.4 Vergleich tmux vs. screen

4.5 Wann welches Tool?

tmux verwenden wenn:

• Modernes System mit Homebrew/apt
• Komplexe Layouts mit vielen Panes
• Umfangreiche Anpassungen gewünscht
• Scripting/Automatisierung benötigt

screen verwenden wenn:

• Auf älteren/minimalen Systemen arbeiten
• Kein tmux installiert und keine Root-Rechte
• Einfache Anforderungen (nur Sessions)
• Gewohnte Umgebung

Empfehlung: Auf eigenen Systemen tmux installieren und verwenden. screen-Kenntnisse sind nützlich für Server ohne tmux.

5 Remote-Session-Management

Der Hauptvorteil von Terminal-Multiplexern: Sessions überleben Verbindungsabbrüche.

5.1 Typischer SSH-Workflow

# 1. Mit Server verbinden
ssh user@server

# 2. tmux starten oder verbinden
tmux new -s arbeit
# oder
tmux attach -t arbeit

# 3. Arbeiten...

# 4. Sauber trennen (Session läuft weiter)
Prefix + d

# 5. SSH beenden
exit

# 6. Später wieder verbinden
ssh user@server
tmux attach -t arbeit
# Alles ist noch da!

5.2 Automatische tmux-Session

In ~/.bashrc oder ~/.zshrc auf dem Server:

# Automatisch tmux starten bei SSH-Login
if [-z "$TMUX"](-z%20"$TMUX".md) && [-n "$SSH_CONNECTION"](-n%20"$SSH_CONNECTION".md); then
    tmux attach -t default || tmux new -s default
fi

Vorsicht: Kann Probleme bei SCP/SFTP verursachen. Besser:

# Nur bei interaktiver Shell
if [-z "$TMUX"](-z%20"$TMUX".md) && [-n "$SSH_CONNECTION"](-n%20"$SSH_CONNECTION".md) && [$- == *i*]($-%20==%20*i*.md); then
    tmux attach -t default 2>/dev/null || tmux new -s default
fi

5.3 SSH-Verbindung in tmux

# Lokale tmux-Session
tmux new -s remote-arbeit

# Innerhalb tmux: SSH-Verbindung
ssh user@server

# Wenn Verbindung abbricht: tmux-Session lokal intakt
# Einfach erneut SSH starten

5.4 Mehrere Server verwalten

# Session für jeden Server
tmux new -s server1 -d "ssh user@server1"
tmux new -s server2 -d "ssh user@server2"

# Zwischen Sessions wechseln
Prefix + s

# Oder: Ein Window pro Server
tmux new -s servers
tmux new-window -t servers -n "web" "ssh user@webserver"
tmux new-window -t servers -n "db" "ssh user@dbserver"
tmux new-window -t servers -n "app" "ssh user@appserver"

5.5 Session-Sharing

Mehrere Benutzer können dieselbe Session sehen (Pair Programming, Support):

tmux:

# Benutzer 1: Session erstellen
tmux new -s shared

# Benutzer 2: Gleiche Session (beide sehen dasselbe)
tmux attach -t shared

# Benutzer 2: Eigene Ansicht (unabhängige Window-Auswahl)
tmux new -t shared -s user2

screen:

# Multi-User aktivieren (in .screenrc oder zur Laufzeit)
multiuser on
acladd username

# Anderer Benutzer verbindet
screen -x user/sessionname

5.6 Persistente Layouts

Session beim Start mit vordefiniertem Layout:

Script-basiert:

#!/bin/zsh
# ~/scripts/dev-session.sh

SESSION="dev"

# Prüfen ob Session existiert
tmux has-session -t $SESSION 2>/dev/null

if [ $? != 0 ]; then
    # Neue Session mit erstem Window
    tmux new-session -d -s $SESSION -n "editor"

    # Editor-Window: vim
    tmux send-keys -t $SESSION:editor "cd ~/projekt && vim" Enter

    # Zweites Window: Server
    tmux new-window -t $SESSION -n "server"
    tmux send-keys -t $SESSION:server "cd ~/projekt && npm run dev" Enter

    # Drittes Window: Terminal (gesplittet)
    tmux new-window -t $SESSION -n "term"
    tmux split-window -h -t $SESSION:term
    tmux send-keys -t $SESSION:term.1 "cd ~/projekt" Enter
    tmux send-keys -t $SESSION:term.2 "cd ~/projekt && git status" Enter

    # Zum Editor-Window wechseln
    tmux select-window -t $SESSION:editor
fi

# Zur Session verbinden
tmux attach -t $SESSION

Mit tmuxinator (empfohlen für komplexe Setups):

# Installation
brew install tmuxinator

# Neues Projekt erstellen
tmuxinator new projekt

# ~/.config/tmuxinator/projekt.yml
name: projekt
root: ~/projekt

windows:
  - editor:
      layout: main-vertical
      panes:
        - vim
        - git status
  - server:
      panes:
        - npm run dev
  - logs:
      panes:
        - tail -f logs/app.log
        - tail -f logs/error.log

# Session starten
tmuxinator start projekt

# Session beenden
tmuxinator stop projekt

5.7 tmux und SSH-Agent

SSH-Agent-Forwarding kann in tmux problematisch sein. Lösung:

# In ~/.tmux.conf
set -g update-environment "SSH_AUTH_SOCK SSH_AGENT_PID"

# Oder: Symlink-Methode in ~/.zshrc
if [-n "$SSH_AUTH_SOCK"](-n%20"$SSH_AUTH_SOCK".md) && ["$SSH_AUTH_SOCK" != "$HOME/.ssh/ssh_auth_sock"]("$SSH_AUTH_SOCK"%20!=%20"$HOME/.ssh/ssh_auth_sock".md); then
    ln -sf "$SSH_AUTH_SOCK" "$HOME/.ssh/ssh_auth_sock"
fi
export SSH_AUTH_SOCK="$HOME/.ssh/ssh_auth_sock"

5.8 Nützliche Aliase

# In ~/.zshrc

# tmux-Aliase
alias ta='tmux attach -t'
alias tl='tmux list-sessions'
alias tn='tmux new -s'
alias tk='tmux kill-session -t'

# Schnell zu Session oder neue erstellen
t() {
    if [-n "$1"](-n%20"$1".md); then
        tmux attach -t "$1" 2>/dev/null || tmux new -s "$1"
    else
        tmux attach 2>/dev/null || tmux new -s main
    fi
}

5.9 Cheatsheet

Session-Management:

tmux                         Neue Session
tmux new -s NAME             Benannte Session
tmux ls                      Sessions auflisten
tmux attach -t NAME          Zu Session verbinden
tmux kill-session -t NAME    Session beenden
Prefix + d                   Detach
Prefix + s                   Session-Auswahl

Windows:

Prefix + c                   Neues Window
Prefix + n / p               Nächstes / Vorheriges
Prefix + 0-9                 Zu Window wechseln
Prefix + ,                   Umbenennen
Prefix + &                   Schließen
Prefix + w                   Window-Liste

Panes:

Prefix + %                   Vertikal teilen
Prefix + "                   Horizontal teilen
Prefix + Pfeiltasten         Navigation
Prefix + z                   Zoom (Vollbild)
Prefix + x                   Schließen
Prefix + Space               Layout wechseln
Prefix + !                   Pane → Window

Copy-Mode:

Prefix + [                   Copy-Mode starten
q / Escape                   Beenden
Space / v                    Auswahl starten
Enter / y                    Kopieren
Prefix + ]                   Einfügen

SSH-Keys

SSH-Keys ermöglichen sichere, passwortlose Authentifizierung bei Remote-Servern. Sie sind sicherer als Passwörter und essentiell für automatisierte Workflows.

1 SSH-Keys erstellen & verwalten

1.1 Funktionsweise

SSH verwendet asymmetrische Kryptografie:

Der Private Key verlässt niemals den lokalen Rechner. Der Public Key wird auf alle Server kopiert, zu denen man sich verbinden möchte.

1.2 Algorithmen

1.3 Key erstellen

Ed25519 (empfohlen):

ssh-keygen -t ed25519 -C "kommentar@example.com"

RSA (für Kompatibilität):

ssh-keygen -t rsa -b 4096 -C "kommentar@example.com"

Interaktiver Dialog:

Generating public/private ed25519 key pair.
Enter file in which to save the key (/Users/max/.ssh/id_ed25519):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /Users/max/.ssh/id_ed25519
Your public key has been saved in /Users/max/.ssh/id_ed25519.pub

Optionen:

Beispiele:

# Standard Ed25519 Key
ssh-keygen -t ed25519 -C "max@example.com"

# Key mit bestimmtem Namen
ssh-keygen -t ed25519 -C "github" -f ~/.ssh/github_ed25519

# Key ohne Passphrase (für Automatisierung)
ssh-keygen -t ed25519 -C "automation" -f ~/.ssh/automation -N ""

# RSA Key für ältere Systeme
ssh-keygen -t rsa -b 4096 -C "legacy-server" -f ~/.ssh/legacy_rsa

1.4 Passphrase

Die Passphrase verschlüsselt den Private Key:

Empfehlung: Immer Passphrase verwenden, SSH-Agent für Komfort nutzen.

Passphrase ändern:

ssh-keygen -p -f ~/.ssh/id_ed25519

1.5 Dateien und Berechtigungen

Standard-Speicherort: ~/.ssh/

Berechtigungen setzen:

# Verzeichnis
chmod 700 ~/.ssh

# Private Keys
chmod 600 ~/.ssh/id_*
chmod 600 ~/.ssh/*_ed25519
chmod 600 ~/.ssh/*_rsa

# Public Keys
chmod 644 ~/.ssh/*.pub

# Konfigurationsdateien
chmod 600 ~/.ssh/config
chmod 600 ~/.ssh/authorized_keys
chmod 644 ~/.ssh/known_hosts

SSH verweigert Keys mit zu offenen Berechtigungen!

1.6 Public Key auf Server kopieren

Methode 1: ssh-copy-id (empfohlen)

ssh-copy-id user@server

# Bestimmten Key
ssh-copy-id -i ~/.ssh/github_ed25519.pub user@server

Methode 2: Manuell

# Public Key anzeigen
cat ~/.ssh/id_ed25519.pub

# Auf Server: Key in authorized_keys einfügen
ssh user@server
mkdir -p ~/.ssh
chmod 700 ~/.ssh
echo "PUBLICKEY" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Methode 3: Einzeiler

cat ~/.ssh/id_ed25519.pub | ssh user@server "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

1.7 Keys verwalten

Alle Keys auflisten:

ls -la ~/.ssh/

# Fingerprints anzeigen
for key in ~/.ssh/id_*; do
    [-f "$key" && "$key" != *.pub](-f%20"$key"%20&&%20"$key"%20!=%20*.pub.md) && ssh-keygen -lf "$key"
done

Key-Fingerprint anzeigen:

# MD5 (älteres Format)
ssh-keygen -l -E md5 -f ~/.ssh/id_ed25519.pub

# SHA256 (Standard)
ssh-keygen -l -f ~/.ssh/id_ed25519.pub

Public Key aus Private Key extrahieren:

ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub

Key löschen:

# Beide Dateien entfernen
rm ~/.ssh/id_ed25519 ~/.ssh/id_ed25519.pub

# Aus authorized_keys auf Server entfernen
ssh user@server
nano ~/.ssh/authorized_keys  # Zeile entfernen

1.8 Mehrere Keys

Für verschiedene Zwecke separate Keys erstellen:

# Persönlicher Key
ssh-keygen -t ed25519 -C "personal" -f ~/.ssh/personal_ed25519

# Arbeit
ssh-keygen -t ed25519 -C "work" -f ~/.ssh/work_ed25519

# GitHub
ssh-keygen -t ed25519 -C "github" -f ~/.ssh/github_ed25519

# Automation (ohne Passphrase)
ssh-keygen -t ed25519 -C "automation" -f ~/.ssh/automation_ed25519 -N ""

Die Zuordnung erfolgt über ~/.ssh/config (siehe Abschnitt 5.2).

2 SSH-Konfiguration (~/.ssh/config)

Die SSH-Konfiguration vereinfacht Verbindungen und ermöglicht hostspezifische Einstellungen.

2.1 Grundstruktur

Host ALIAS
    Option Wert
    Option Wert

Einfaches Beispiel:

Host server
    HostName 192.168.1.100
    User admin
    Port 22

Statt ssh admin@192.168.1.100 genügt nun ssh server.

2.2 Wichtige Optionen

2.3 Vollständige Beispielkonfiguration

# ~/.ssh/config

# === Globale Einstellungen ===
Host *
    AddKeysToAgent yes
    UseKeychain yes
    IdentitiesOnly yes
    ServerAliveInterval 60
    ServerAliveCountMax 3

# === Arbeit ===
Host work
    HostName work-server.company.com
    User max.mustermann
    IdentityFile ~/.ssh/work_ed25519

Host work-*
    User max.mustermann
    IdentityFile ~/.ssh/work_ed25519

Host work-web
    HostName 10.0.1.10

Host work-db
    HostName 10.0.1.20

Host work-app
    HostName 10.0.1.30

# === Persönlich ===
Host home
    HostName home.dyndns.org
    User max
    Port 2222
    IdentityFile ~/.ssh/personal_ed25519

Host pi
    HostName 192.168.1.50
    User pi
    IdentityFile ~/.ssh/personal_ed25519

# === GitHub ===
Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/github_ed25519

# Zweiter GitHub Account
Host github-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/work_github_ed25519

# === GitLab ===
Host gitlab.com
    HostName gitlab.com
    User git
    IdentityFile ~/.ssh/gitlab_ed25519

# === Jump Host / Bastion ===
Host bastion
    HostName bastion.company.com
    User jump
    IdentityFile ~/.ssh/work_ed25519

Host internal-*
    ProxyJump bastion
    User admin
    IdentityFile ~/.ssh/work_ed25519

Host internal-web
    HostName 10.10.1.10

Host internal-db
    HostName 10.10.1.20

# === Port Forwarding ===
Host tunnel-db
    HostName dbserver.company.com
    User admin
    LocalForward 5432 localhost:5432
    IdentityFile ~/.ssh/work_ed25519

# === Alte/Legacy Server ===
Host legacy
    HostName old-server.example.com
    User root
    IdentityFile ~/.ssh/legacy_rsa
    PubkeyAcceptedAlgorithms +ssh-rsa
    HostkeyAlgorithms +ssh-rsa

2.4 Wildcards und Patterns

# Alle Hosts
Host *
    ServerAliveInterval 60

# Alle .company.com Hosts
Host *.company.com
    User admin
    IdentityFile ~/.ssh/work_ed25519

# Alle außer bestimmte
Host * !github.com !gitlab.com
    IdentityFile ~/.ssh/default_ed25519

2.5 Jump Hosts (ProxyJump)

Verbindung über einen Zwischenserver (Bastion Host):

# Klassisch (alt)
Host internal
    ProxyCommand ssh -W %h:%p bastion

# Modern (empfohlen)
Host internal
    ProxyJump bastion

Mehrere Hops:

Host deep-internal
    ProxyJump bastion,middle-server

Kommandozeile:

ssh -J bastion internal-server
ssh -J bastion,middle deep-server

2.6 Port Forwarding

Local Forward (Zugriff auf Remote-Dienst):

# Remote-Datenbank lokal verfügbar machen
Host tunnel-postgres
    HostName dbserver.com
    LocalForward 5432 localhost:5432

ssh tunnel-postgres
# Dann: psql -h localhost -p 5432

Remote Forward (Lokalen Dienst remote verfügbar):

# Lokalen Webserver remote verfügbar machen
Host expose-local
    HostName server.com
    RemoteForward 8080 localhost:3000

Dynamic Forward (SOCKS Proxy):

Host socks-proxy
    HostName server.com
    DynamicForward 1080

ssh socks-proxy
# Browser: SOCKS5 Proxy auf localhost:1080

2.7 Mehrere GitHub/GitLab Accounts

# Persönlicher GitHub Account
Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/github_personal

# Arbeits-GitHub Account
Host github-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/github_work

Verwendung:

# Persönlich (Standard)
git clone git@github.com:user/repo.git

# Arbeit
git clone git@github-work:company/repo.git

# In bestehendem Repo Remote ändern
git remote set-url origin git@github-work:company/repo.git

2.8 Reihenfolge und Priorität

SSH liest die Config von oben nach unten. Der erste Match für jede Option gewinnt.

# RICHTIG: Spezifisch vor allgemein
Host work-server
    User admin

Host *
    User default

# FALSCH: Allgemein überschreibt spezifisch
Host *
    User default

Host work-server
    User admin  # Wird ignoriert!

Empfohlene Struktur:

1. Spezifische Hosts
2. Gruppen-Patterns (work-*, *.company.com)
3. Globale Einstellungen (Host *)

3 SSH-Agent, Konfiguration und Sicherheit

3.1 SSH-Agent Grundlagen

Der SSH-Agent speichert entschlüsselte Private Keys im Speicher, sodass die Passphrase nicht bei jeder Verbindung eingegeben werden muss.

Funktionsweise:

┌─────────────────────────────────────────────────────┐
│                    SSH-Agent                        │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  │
│  │ Key 1       │  │ Key 2       │  │ Key 3       │  │
│  │ (entschl.)  │  │ (entschl.)  │  │ (entschl.)  │  │
│  └─────────────┘  └─────────────┘  └─────────────┘  │
└─────────────────────────────────────────────────────┘
        ↑                   ↑                ↑
   ssh server1         ssh server2      git push
   (kein Passwort)     (kein Passwort)  (kein Passwort)

3.2 Agent unter macOS

macOS startet den SSH-Agent automatisch. Die Integration mit der Keychain speichert Passphrasen dauerhaft.

Keychain-Integration aktivieren:

# ~/.ssh/config
Host *
    AddKeysToAgent yes
    UseKeychain yes

Key manuell zur Keychain hinzufügen:

# Key zum Agent hinzufügen (Passphrase in Keychain speichern)
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

# Alle Standard-Keys laden
ssh-add --apple-load-keychain

3.3 Agent-Befehle

Beispiele:

# Key hinzufügen
ssh-add ~/.ssh/work_ed25519

# Alle Keys anzeigen
ssh-add -l

# Key für 1 Stunde hinzufügen
ssh-add -t 3600 ~/.ssh/sensitive_ed25519

# Alle Keys entfernen (Sicherheit)
ssh-add -D

3.4 Agent Forwarding

Agent Forwarding erlaubt die Nutzung lokaler Keys auf Remote-Servern, ohne die Keys dorthin zu kopieren.

Lokal          →     Server A     →     Server B
(Agent mit Keys)     (kein Key)        (kein Key)
                     nutzt lokalen     nutzt lokalen
                     Agent             Agent via A

Aktivieren:

# ~/.ssh/config
Host trusted-server
    ForwardAgent yes

Oder per Kommandozeile:

ssh -A trusted-server

Sicherer: ProxyJump statt Agent Forwarding

Host internal
    ProxyJump bastion

ProxyJump ist sicherer, da der Zwischenserver keinen Zugriff auf den Agent erhält.

3.5 Sicherheits-Best-Practices

Key-Management:

Berechtigungen:

# Einmalig: Alle Berechtigungen korrekt setzen
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_* ~/.ssh/config ~/.ssh/authorized_keys
chmod 644 ~/.ssh/*.pub ~/.ssh/known_hosts

authorized_keys absichern:

# Optionen vor dem Key einschränken
# In ~/.ssh/authorized_keys auf dem Server:

# Nur von bestimmter IP
from="192.168.1.100" ssh-ed25519 AAAA... user@host

# Kein Agent-Forwarding, kein PTY
no-agent-forwarding,no-pty ssh-ed25519 AAAA... automation@host

# Nur bestimmten Befehl erlauben
command="/usr/local/bin/backup.sh" ssh-ed25519 AAAA... backup@host

# Kombination
from="10.0.0.*",no-agent-forwarding,no-port-forwarding ssh-ed25519 AAAA...

Verfügbare Optionen:

3.6 known_hosts

Die Datei ~/.ssh/known_hosts speichert Fingerprints bekannter Server und schützt vor Man-in-the-Middle-Angriffen.

Erste Verbindung:

The authenticity of host 'server.com (192.168.1.100)' can't be established.
ED25519 key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

Fingerprint verifizieren:

# Auf dem Server
ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub

# Vergleichen mit angezeigtem Fingerprint

Host entfernen (bei legitimem Key-Wechsel):

ssh-keygen -R server.com
ssh-keygen -R 192.168.1.100

Hashed known_hosts (mehr Privatsphäre):

# ~/.ssh/config
Host *
    HashKnownHosts yes

3.7 Server-Konfiguration (sshd_config)

Auf dem Server in /etc/ssh/sshd_config:

# Nur Key-Authentifizierung
PubkeyAuthentication yes
PasswordAuthentication no
PermitEmptyPasswords no

# Root-Login verbieten oder einschränken
PermitRootLogin no
# Oder: PermitRootLogin prohibit-password

# Nur bestimmte User erlauben
AllowUsers admin deploy

# Nur bestimmte Gruppen
AllowGroups sshusers

# Agent-Forwarding global deaktivieren
AllowAgentForwarding no

# Idle-Timeout
ClientAliveInterval 300
ClientAliveCountMax 2

# Sichere Algorithmen (modern)
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org
HostKeyAlgorithms ssh-ed25519,rsa-sha2-512,rsa-sha2-256
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com

Nach Änderungen:

# Syntax prüfen
sudo sshd -t

# Dienst neu starten
sudo systemctl restart sshd
# Oder macOS:
sudo launchctl stop com.openssh.sshd
sudo launchctl start com.openssh.sshd

3.8 Troubleshooting

Verbindung debuggen:

# Verbose-Modus
ssh -v user@server      # Level 1
ssh -vv user@server     # Level 2
ssh -vvv user@server    # Level 3 (sehr detailliert)

Häufige Probleme:

Agent prüfen:

# Agent läuft?
echo $SSH_AUTH_SOCK

# Keys geladen?
ssh-add -l

# Agent neu starten (falls nötig)
eval $(ssh-agent -s)
ssh-add

Berechtigungen prüfen:

# Lokal
ls -la ~/.ssh/

# Auf Server
ls -la ~/.ssh/
ls -la ~/.ssh/authorized_keys

3.9 Nützliche Aliase und Funktionen

# ~/.zshrc

# SSH-Key Fingerprints anzeigen
alias ssh-fingerprints='for key in ~/.ssh/id_*; do [-f "$key" && "$key" != *.pub](-f%20"$key"%20&&%20"$key"%20!=%20*.pub.md) && ssh-keygen -lf "$key"; done'

# Neuen Ed25519 Key erstellen
ssh-newkey() {
    local name="${1:-id_ed25519}"
    local comment="${2:-$(whoami)@$(hostname)}"
    ssh-keygen -t ed25519 -C "$comment" -f ~/.ssh/"$name"
}

# Key zu Server kopieren
ssh-copykey() {
    local key="${1:-~/.ssh/id_ed25519.pub}"
    local server="$2"
    if [-z "$server"](-z%20"$server".md); then
        echo "Usage: ssh-copykey [keyfile] server"
        return 1
    fi
    ssh-copy-id -i "$key" "$server"
}

# SSH-Verbindung testen
ssh-test() {
    ssh -o BatchMode=yes -o ConnectTimeout=5 "$1" echo "OK" 2>&1
}

3.10 Cheatsheet

Keys erstellen:

ssh-keygen -t ed25519 -C "comment"           Neuer Ed25519 Key
ssh-keygen -t ed25519 -f ~/.ssh/name         Mit bestimmtem Namen
ssh-keygen -p -f ~/.ssh/id_ed25519           Passphrase ändern
ssh-keygen -y -f private > public            Public aus Private
ssh-keygen -lf ~/.ssh/id_ed25519             Fingerprint anzeigen

Keys verteilen:

ssh-copy-id user@server                      Key auf Server kopieren
ssh-copy-id -i ~/.ssh/key.pub user@server    Bestimmten Key kopieren

Agent:

ssh-add                                      Standard-Keys laden
ssh-add ~/.ssh/key                           Bestimmten Key laden
ssh-add -l                                   Geladene Keys anzeigen
ssh-add -d ~/.ssh/key                        Key entfernen
ssh-add -D                                   Alle Keys entfernen
ssh-add --apple-use-keychain ~/.ssh/key      In macOS Keychain (neu)

Verbindung:

ssh server                                   Mit Alias verbinden
ssh -i ~/.ssh/key user@server                Mit bestimmtem Key
ssh -J bastion internal                      Über Jump-Host
ssh -L 8080:localhost:80 server              Local Port Forward
ssh -v server                                Debug-Modus

Wartung:

ssh-keygen -R hostname                       Host aus known_hosts entfernen
chmod 700 ~/.ssh                             Verzeichnis-Berechtigung
chmod 600 ~/.ssh/id_* ~/.ssh/config          Datei-Berechtigungen

ZLE / ZLE-Widgets

Der Zsh Line Editor (ZLE) ist das Herzstück der Kommandozeilen-Bearbeitung in zsh. Er ermöglicht umfangreiche Anpassungen der Eingabe, eigene Tastenkürzel und mächtige Widgets.

1 Grundlagen & Architektur

1.1 Was ist ZLE?

ZLE ist der eingebaute Zeileneditor von zsh, vergleichbar mit readline in bash. Er verarbeitet alle Tastatureingaben und stellt Funktionen bereit für:

• Cursor-Bewegung und Textbearbeitung
• History-Navigation
• Tab-Completion
• Vi- und Emacs-Modus
• Benutzerdefinierte Widgets

1.2 Keymaps

ZLE organisiert Tastenbelegungen in Keymaps:

Aktuelle Keymap anzeigen:

bindkey -l          # Alle Keymaps auflisten
bindkey -M emacs    # Bindungen der emacs-Keymap
bindkey -M viins    # Bindungen des vi-Insert-Modus

Keymap wechseln:

# Emacs-Modus (Standard)
bindkey -e

# Vi-Modus
bindkey -v

1.3 Widgets

Ein Widget ist eine Funktion, die an eine Taste gebunden werden kann. ZLE stellt über 150 eingebaute Widgets bereit.

Eingebaute Widgets anzeigen:

zle -la             # Alle Widgets auflisten
zle -la | wc -l     # Anzahl
zle -la | grep hist # Widgets mit "hist" im Namen

Wichtige eingebaute Widgets:

1.4 Aktuelle Bindungen anzeigen

# Alle Bindungen
bindkey

# Bestimmte Taste
bindkey "^A"        # Was macht Ctrl+A?
bindkey "^[[A"      # Was macht Pfeil-Hoch?

# Widget suchen
bindkey | grep kill

1.5 Escape-Sequenzen

Tasten werden als Escape-Sequenzen dargestellt:

Terminal-Sequenzen ermitteln:

# Methode 1: cat
cat -v
# Dann Taste drücken, z.B. Pfeil hoch zeigt: ^[[A

# Methode 2: read
read -k
# Taste drücken

# Methode 3: Ctrl+V in zsh
# Ctrl+V drücken, dann Taste → zeigt Sequenz

Häufige Terminal-Sequenzen:

1.6 ZLE-Variablen

Innerhalb eines Widgets verfügbare Variablen:

2 Eigene Widgets schreiben

2.1 Widget-Grundstruktur

# Widget-Funktion definieren
my-widget() {
    # Code hier
}

# Als Widget registrieren
zle -N my-widget

# An Taste binden
bindkey "^X^M" my-widget

2.2 Einfache Beispiele

Text einfügen:

# Aktuelles Datum einfügen
insert-date() {
    LBUFFER+=$(date +%Y-%m-%d)
}
zle -N insert-date
bindkey "^Xd" insert-date

# Timestamp einfügen
insert-timestamp() {
    LBUFFER+=$(date +"%Y-%m-%d %H:%M:%S")
}
zle -N insert-timestamp
bindkey "^Xt" insert-timestamp

Buffer manipulieren:

# Zeile in Großbuchstaben
uppercase-line() {
    BUFFER=${BUFFER:u}
}
zle -N uppercase-line
bindkey "^Xu" uppercase-line

# Zeile in Kleinbuchstaben
lowercase-line() {
    BUFFER=${BUFFER:l}
}
zle -N lowercase-line
bindkey "^Xl" lowercase-line

# Wort unter Cursor in Großbuchstaben
uppercase-word() {
    local word="${LBUFFER##* }"
    LBUFFER="${LBUFFER% *} ${word:u}"
}
zle -N uppercase-word

Sudo voranstellen:

prepend-sudo() {
    if [[ $BUFFER != sudo\ *](`.md); then
        BUFFER="sudo $BUFFER"
        CURSOR+=5
    fi
}
zle -N prepend-sudo
bindkey "^[s" prepend-sudo   # Alt+S

2.3 Mit History arbeiten

# Letzten Befehl mit sudo wiederholen
sudo-last-command() {
    BUFFER="sudo $(fc -ln -1)"
    zle accept-line
}
zle -N sudo-last-command
bindkey "^[!" sudo-last-command

# Letztes Argument des vorherigen Befehls
insert-last-arg() {
    zle insert-last-word
}
zle -N insert-last-arg
bindkey "^[." insert-last-arg   # Alt+. (oft schon belegt)

2.4 Externe Befehle einbinden

# fzf für History-Suche
fzf-history() {
    local selected
    selected=$(fc -ln 1 | fzf --tac --no-sort)
    if [-n "$selected"](-n%20"$selected".md); then
        BUFFER="$selected"
        CURSOR=$#BUFFER
    fi
    zle redisplay
}
zle -N fzf-history
bindkey "^R" fzf-history

# fzf für Dateiauswahl
fzf-file() {
    local file
    file=$(fzf)
    if [-n "$file"](-n%20"$file".md); then
        LBUFFER+="${(q)file}"  # Quoted einfügen
    fi
    zle redisplay
}
zle -N fzf-file
bindkey "^Xf" fzf-file

# fzf für Verzeichniswechsel
fzf-cd() {
    local dir
    dir=$(find . -type d 2>/dev/null | fzf)
    if [-n "$dir"](-n%20"$dir".md); then
        cd "$dir"
        zle reset-prompt
    fi
}
zle -N fzf-cd
bindkey "^Xc" fzf-cd

2.5 Clipboard-Integration

# Auswahl in Clipboard kopieren (macOS)
copy-to-clipboard() {
    echo -n "$BUFFER" | pbcopy
    zle -M "Copied to clipboard"
}
zle -N copy-to-clipboard
bindkey "^Xy" copy-to-clipboard

# Aus Clipboard einfügen
paste-from-clipboard() {
    LBUFFER+=$(pbpaste)
}
zle -N paste-from-clipboard
bindkey "^Xp" paste-from-clipboard

# Kill-Ring nach Clipboard
copy-kill-ring() {
    echo -n "$CUTBUFFER" | pbcopy
    zle -M "Kill buffer copied"
}
zle -N copy-kill-ring

2.6 Widgets mit Parametern

# Widget das andere Widgets aufruft
surround-with-quotes() {
    BUFFER="\"$BUFFER\""
    CURSOR=$#BUFFER
}
zle -N surround-with-quotes
bindkey "^X\"" surround-with-quotes

# Flexibler: Wrapper-Funktion
surround-with() {
    local open="$1" close="$2"
    BUFFER="${open}${BUFFER}${close}"
    CURSOR=$#BUFFER
}

surround-parens()   { surround-with '(' ')'; }
surround-brackets() { surround-with '[' ']'; }
surround-braces()   { surround-with '{' '}'; }
surround-single()   { surround-with "'" "'"; }
surround-double()   { surround-with '"' '"'; }

zle -N surround-parens
zle -N surround-brackets
zle -N surround-braces
zle -N surround-single
zle -N surround-double

bindkey "^X(" surround-parens
bindkey "^X[" surround-brackets
bindkey "^X{" surround-braces
bindkey "^X'" surround-single
bindkey '^X"' surround-double

2.7 Rückgabewerte und Fehlerbehandlung

# Widget mit Fehlermeldung
safe-rm() {
    if [-z "$BUFFER"](-z%20"$BUFFER".md); then
        zle -M "Buffer ist leer"
        return 1
    fi

    if ["$BUFFER" == rm\ *]("$BUFFER"%20==%20rm\%20*.md); then
        BUFFER="${BUFFER/rm /rm -i }"
        zle -M "rm → rm -i (interaktiv)"
    fi
}
zle -N safe-rm
bindkey "^Xr" safe-rm

3 Erweiterte Shortcuts / ZLE-Bindings

3.1 bindkey Syntax

bindkey [optionen] "taste" widget

3.2 Tastenkombinationen definieren

# Einzelne Taste
bindkey "^A" beginning-of-line

# Tastensequenz
bindkey "^X^F" fzf-file

# Mit Escape/Alt
bindkey "^[b" backward-word     # Alt+B
bindkey "\eb" backward-word     # Alternative Notation

# Pfeiltasten
bindkey "^[[A" history-search-backward
bindkey "^[[B" history-search-forward

# Funktionstasten
bindkey "^[OP" my-f1-widget     # F1
bindkey "^[[15~" my-f5-widget   # F5

3.3 Makros (String-Bindungen)

Mit -s wird ein String eingefügt statt ein Widget aufgerufen:

# Pipe zu less
bindkey -s "^Xl" " | less"

# Pipe zu grep
bindkey -s "^Xg" " | grep "

# Redirect Stderr
bindkey -s "^Xe" " 2>&1"

# Redirect zu /dev/null
bindkey -s "^Xn" " > /dev/null 2>&1"

# Git Status
bindkey -s "^Gs" "git status\n"

# Git Diff
bindkey -s "^Gd" "git diff\n"

# Häufige Befehle
bindkey -s "^Ll" "ll\n"
bindkey -s "^Lc" "clear\n"

3.4 Keymap-spezifische Bindungen

# Nur im Vi-Insert-Modus
bindkey -M viins "jk" vi-cmd-mode

# Nur im Vi-Command-Modus
bindkey -M vicmd "H" beginning-of-line
bindkey -M vicmd "L" end-of-line

# Nur im Emacs-Modus
bindkey -M emacs "^Xe" edit-command-line

3.5 Bindung entfernen

# Binding entfernen
bindkey -r "^X^K"

# In bestimmter Keymap
bindkey -M viins -r "^A"

3.6 Alle Bindungen exportieren/importieren

# Aktuelle Bindungen als Befehle ausgeben
bindkey -L > ~/bindkeys-backup.zsh

# Wiederherstellen
source ~/bindkeys-backup.zsh

4 Erweiterte Tastenkombinationen

4.1 Emacs-Modus Referenz

Navigation:

Bearbeitung:

History:

Sonstiges:

4.2 Vi-Modus Referenz

Modus wechseln:

Navigation (Command-Modus):

Bearbeitung (Command-Modus):

History (Command-Modus):

4.3 Eigene Keymap erstellen

# Neue Keymap basierend auf emacs
bindkey -N mymap emacs

# Anpassungen
bindkey -M mymap "^Xd" insert-date
bindkey -M mymap "^Xs" prepend-sudo

# Keymap aktivieren
bindkey -A mymap main

4.4 Contextuelle Bindings

# Binding nur bei bestimmter Eingabe
# Beispiel: Tab verhält sich unterschiedlich

smart-tab() {
    if [-z "$LBUFFER"](-z%20"$LBUFFER".md); then
        # Leere Zeile: 4 Spaces einfügen
        LBUFFER+="    "
    elif ["$LBUFFER" =~ '^ +$']("$LBUFFER"%20=~%20'^%20+$'.md); then
        # Nur Whitespace: weitere Spaces
        LBUFFER+="    "
    else
        # Sonst: normale Completion
        zle expand-or-complete
    fi
}
zle -N smart-tab
bindkey "^I" smart-tab

5 Beispiele & Use-Cases

5.1 Produktivitäts-Widgets

Befehl in Editor öffnen:

# Bereits eingebaut, aber oft nicht gebunden
autoload -U edit-command-line
zle -N edit-command-line
bindkey "^Xe" edit-command-line
bindkey "^X^E" edit-command-line

Git-Integration:

# Git Branch wechseln mit fzf
fzf-git-branch() {
    local branch
    branch=$(git branch --all | grep -v HEAD | fzf --preview 'git log --oneline -20 {1}')
    branch=${branch#remotes/origin/}
    branch=${branch## }
    if [-n "$branch"](-n%20"$branch".md); then
        BUFFER="git checkout $branch"
        zle accept-line
    fi
}
zle -N fzf-git-branch
bindkey "^Gb" fzf-git-branch

# Git Status anzeigen (ohne Ausführung)
show-git-status() {
    zle -M "$(git status -s 2>/dev/null || echo 'Not a git repo')"
}
zle -N show-git-status
bindkey "^Gs" show-git-status

# Git Add mit fzf
fzf-git-add() {
    local files
    files=$(git status -s | fzf -m | awk '{print $2}')
    if [-n "$files"](-n%20"$files".md); then
        BUFFER="git add ${files//$'\n'/ }"
        CURSOR=$#BUFFER
    fi
    zle redisplay
}
zle -N fzf-git-add
bindkey "^Ga" fzf-git-add

Verzeichnis-Navigation:

# Schnell zu häufigen Verzeichnissen
goto-projects() {
    local dir
    dir=$(find ~/projects -maxdepth 1 -type d | fzf)
    if [-n "$dir"](-n%20"$dir".md); then
        cd "$dir"
        zle reset-prompt
    fi
}
zle -N goto-projects
bindkey "^Xp" goto-projects

# Parent Directory
goto-parent() {
    cd ..
    zle reset-prompt
}
zle -N goto-parent
bindkey "^X." goto-parent

# Zurück zum vorherigen Verzeichnis
goto-previous() {
    cd - > /dev/null
    zle reset-prompt
}
zle -N goto-previous
bindkey "^X-" goto-previous

5.2 Textmanipulation

Pipe-Operatoren schnell einfügen:

# Pipe-Menü
pipe-menu() {
    local pipes=(
        "| less"
        "| grep "
        "| head -20"
        "| tail -20"
        "| wc -l"
        "| sort"
        "| sort -u"
        "| xargs "
        "| awk '{print \$1}'"
        "| sed 's///g'"
        "> /dev/null 2>&1"
        "2>&1"
    )
    local selected
    selected=$(printf '%s\n' "${pipes[@]}" | fzf --prompt="Pipe: ")
    if [-n "$selected"](-n%20"$selected".md); then
        LBUFFER+=" $selected"
    fi
    zle redisplay
}
zle -N pipe-menu
bindkey "^X|" pipe-menu

Pfad expandieren:

# ~ und Variablen expandieren
expand-path() {
    BUFFER="${(e)BUFFER}"
}
zle -N expand-path
bindkey "^Xx" expand-path

# Aktuelles Wort zu absolutem Pfad
expand-to-absolute() {
    local word="${LBUFFER##* }"
    local rest="${LBUFFER% *}"
    local abs="${word:A}"
    if ["$rest" == "$LBUFFER"]("$rest"%20==%20"$LBUFFER".md); then
        LBUFFER="$abs"
    else
        LBUFFER="$rest $abs"
    fi
}
zle -N expand-to-absolute
bindkey "^Xa" expand-to-absolute

Wort-Operationen:

# Wort duplizieren
duplicate-word() {
    local word="${LBUFFER##* }"
    LBUFFER+=" $word"
}
zle -N duplicate-word
bindkey "^Xw" duplicate-word

# Wörter rückwärts
reverse-words() {
    local words=(${=BUFFER})
    BUFFER="${(j: :)${(Oa)words}}"
}
zle -N reverse-words

5.3 History-Erweiterungen

History mit Preview:

fzf-history-widget() {
    local selected
    selected=$(fc -rl 1 | fzf +s --tac \
        --preview 'echo {}' \
        --preview-window down:3:wrap)
    if [-n "$selected"](-n%20"$selected".md); then
        # Nummer entfernen
        BUFFER="${selected#*  }"
        CURSOR=$#BUFFER
    fi
    zle redisplay
}
zle -N fzf-history-widget
bindkey "^R" fzf-history-widget

Letzten Befehl modifizieren:

# Letzten Befehl holen und editierbar machen
recall-last-command() {
    BUFFER=$(fc -ln -1)
    CURSOR=$#BUFFER
}
zle -N recall-last-command
bindkey "^[r" recall-last-command

5.4 Prompt-Integration

# Prompt neu zeichnen nach Widget
update-prompt() {
    # Prompt-relevante Variablen aktualisieren
    zle reset-prompt
}

# Nach cd immer Prompt aktualisieren
cd-and-update() {
    if [-n "$BUFFER"](-n%20"$BUFFER".md); then
        zle accept-line
        zle reset-prompt
    fi
}

5.5 Debugging-Widgets

# Aktuellen Buffer anzeigen
debug-buffer() {
    zle -M "BUFFER: '$BUFFER' | LBUFFER: '$LBUFFER' | CURSOR: $CURSOR"
}
zle -N debug-buffer
bindkey "^Xb" debug-buffer

# Letzte Tasten anzeigen
debug-keys() {
    zle -M "KEYS: '$KEYS' | WIDGET: '$WIDGET' | LASTWIDGET: '$LASTWIDGET'"
}
zle -N debug-keys
bindkey "^Xk" debug-keys

# Widget-Liste durchsuchen
search-widgets() {
    local widget
    widget=$(zle -la | fzf --prompt="Widget: ")
    if [-n "$widget"](-n%20"$widget".md); then
        zle -M "Widget: $widget"
    fi
}
zle -N search-widgets
bindkey "^X?" search-widgets

5.6 Vollständige .zshrc-Integration

# ~/.zshrc - ZLE-Konfiguration

# === Grundeinstellungen ===
bindkey -e                              # Emacs-Modus

# === Standard-Verbesserungen ===
bindkey "^[[A" history-search-backward  # Pfeil hoch: History mit Prefix
bindkey "^[[B" history-search-forward   # Pfeil runter: History mit Prefix
bindkey "^[[H" beginning-of-line        # Home
bindkey "^[[F" end-of-line              # End
bindkey "^[[3~" delete-char             # Delete

# === Editor ===
autoload -U edit-command-line
zle -N edit-command-line
bindkey "^Xe" edit-command-line
bindkey "^X^E" edit-command-line

# === Eigene Widgets ===

# Sudo voranstellen
prepend-sudo() {
    [$BUFFER != sudo\ *]($BUFFER%20!=%20sudo\%20*.md) && BUFFER="sudo $BUFFER" && ((CURSOR+=5))
}
zle -N prepend-sudo
bindkey "^[s" prepend-sudo

# Datum einfügen
insert-date() { LBUFFER+=$(date +%Y-%m-%d); }
zle -N insert-date
bindkey "^Xd" insert-date

# Clipboard (macOS)
copy-buffer() { echo -n "$BUFFER" | pbcopy; zle -M "Copied"; }
paste-buffer() { LBUFFER+=$(pbpaste); }
zle -N copy-buffer
zle -N paste-buffer
bindkey "^Xy" copy-buffer
bindkey "^Xp" paste-buffer

# === Makros ===
bindkey -s "^Xl" " | less"
bindkey -s "^Xg" " | grep "
bindkey -s "^Xn" " > /dev/null 2>&1"

# === fzf-Integration (falls installiert) ===
if command -v fzf &> /dev/null; then
    # History
    fzf-history() {
        local cmd=$(fc -ln 1 | fzf --tac --no-sort)
        [-n "$cmd"](-n%20"$cmd".md) && BUFFER="$cmd" && CURSOR=$#BUFFER
        zle redisplay
    }
    zle -N fzf-history
    bindkey "^R" fzf-history

    # Dateien
    fzf-file() {
        local file=$(fzf)
        [-n "$file"](-n%20"$file".md) && LBUFFER+="${(q)file}"
        zle redisplay
    }
    zle -N fzf-file
    bindkey "^Xf" fzf-file

    # Verzeichnisse
    fzf-cd() {
        local dir=$(find . -type d 2>/dev/null | fzf)
        [-n "$dir"](-n%20"$dir".md) && cd "$dir" && zle reset-prompt
    }
    zle -N fzf-cd
    bindkey "^Xc" fzf-cd
fi

5.7 Cheatsheet

Widget erstellen:

widget-name() { ... }           # Funktion definieren
zle -N widget-name              # Als Widget registrieren
bindkey "^Xk" widget-name       # An Taste binden

Wichtige Variablen:

$BUFFER                         # Gesamte Zeile
$LBUFFER                        # Links vom Cursor
$RBUFFER                        # Rechts vom Cursor
$CURSOR                         # Cursor-Position

Bindkey:

bindkey                         # Alle Bindungen
bindkey "^X"                    # Was macht Ctrl+X?
bindkey "^Xk" widget            # Widget binden
bindkey -s "^Xk" "string"       # Makro binden
bindkey -r "^Xk"                # Binding entfernen
bindkey -M viins "jk" vi-cmd    # Keymap-spezifisch

Escape-Sequenzen:

^X   = Ctrl+X
^[   = Escape / Alt
^[[A = Pfeil hoch
^[[B = Pfeil runter
\n   = Enter (für Makros)

Dateisystem & Volumes

Dieses Kapitel behandelt fortgeschrittene Dateisystem-Operationen unter macOS: symbolische und harte Links, Datei-Metadaten, Volume-Management, Disk Images und Backup-Werkzeuge.

1 Links

Links ermöglichen es, auf Dateien oder Verzeichnisse an mehreren Stellen im Dateisystem zu verweisen, ohne die Daten zu duplizieren.

1.1 Symbolische Links (ln -s)

Ein symbolischer Link (Symlink, Softlink) ist ein Verweis auf einen Pfad. Er funktioniert wie eine Verknüpfung und kann auf Dateien oder Verzeichnisse zeigen – auch über Dateisystemgrenzen hinweg.

Syntax:

ln -s ZIEL LINKNAME

Beispiele:

# Symlink auf eine Datei
ln -s ~/Documents/config.yaml ~/.config/app/config.yaml

# Symlink auf ein Verzeichnis
ln -s ~/Dropbox/Projekte ~/Projekte

# Symlink mit relativem Pfad
cd ~/bin
ln -s ../scripts/backup.sh backup

# Symlink in anderem Verzeichnis erstellen
ln -s /opt/homebrew/bin/python3 /usr/local/bin/python

Eigenschaften:

Symlink erkennen:

ls -l ~/Projekte
# lrwxr-xr-x  1 max  staff  20 Jan 15 10:30 Projekte -> Dropbox/Projekte

# Nur Symlinks anzeigen
ls -la | grep "^l"

# Mit file-Befehl
file ~/Projekte
# /Users/max/Projekte: symbolic link to Dropbox/Projekte

1.2 Harte Links (ln)

Ein harter Link ist ein zusätzlicher Verzeichniseintrag für dieselbe Datei (Inode). Die Datei existiert erst dann nicht mehr, wenn alle harten Links gelöscht wurden.

Syntax:

ln ZIEL LINKNAME

Beispiele:

# Harter Link auf Datei
ln original.txt hardlink.txt

# Beide zeigen auf dieselbe Inode
ls -li original.txt hardlink.txt
# 12345678 -rw-r--r--  2 max  staff  100 Jan 15 10:30 hardlink.txt
# 12345678 -rw-r--r--  2 max  staff  100 Jan 15 10:30 original.txt
#    ^-- gleiche Inode-Nummer        ^-- Link-Count = 2

Eigenschaften:

Einschränkungen unter macOS:

# Harte Links auf Verzeichnisse sind nicht erlaubt
ln /Users/max/Documents /Users/max/Docs
# ln: /Users/max/Documents: Is a directory

# Harte Links über Volumes hinweg nicht möglich
ln /Volumes/USB/file.txt ~/file.txt
# ln: /Volumes/USB/file.txt: Cross-device link

1.3 Unterschiede und Anwendungsfälle

Vergleichstabelle:

Wann Symlinks verwenden:

• Verknüpfungen zu Verzeichnissen
• Links über verschiedene Volumes/Partitionen
• Wenn der Link als “Verweis” erkennbar sein soll
• Konfigurationsdateien an mehreren Orten verfügbar machen
• Versionierte Verzeichnisse (z.B. current -> v2.1.0)

Wann harte Links verwenden:

• Backup-Systeme (Time Machine nutzt harte Links)
• Deduplizierung von Dateien
• Wenn die Datei auch nach Löschen des “Originals” erhalten bleiben soll
• Space-effiziente Kopien

Beispiel: Versionierung mit Symlinks:

# Versionen als Verzeichnisse
mkdir -p ~/apps/myapp-1.0.0 ~/apps/myapp-1.1.0 ~/apps/myapp-2.0.0

# Symlink auf aktuelle Version
ln -s ~/apps/myapp-2.0.0 ~/apps/myapp-current

# Update auf neue Version
rm ~/apps/myapp-current
ln -s ~/apps/myapp-2.1.0 ~/apps/myapp-current

# Oder mit ln -sf (force)
ln -sf ~/apps/myapp-2.1.0 ~/apps/myapp-current

1.4 Links verwalten (readlink, unlink)

readlink – Linkziel auslesen:

# Symlink-Ziel anzeigen
readlink ~/Projekte
# Dropbox/Projekte

# Kanonischen (absoluten) Pfad auflösen
readlink -f ~/Projekte
# /Users/max/Dropbox/Projekte

# Auch für nicht existierende Pfade
readlink -f ./relative/path/../file.txt
# /Users/max/current/file.txt

Optionen:

unlink – Link entfernen:

# Symlink entfernen (nicht das Ziel!)
unlink ~/Projekte

# Äquivalent zu rm für einzelne Dateien
rm ~/Projekte

# RICHTIG: Entfernt den Symlink
rm ~/Projekte

# FALSCH: Versucht Inhalt des Zielverzeichnisses zu löschen!
rm -r ~/Projekte/

Links finden:

# Alle Symlinks in einem Verzeichnis
find ~/Documents -type l

# Broken Symlinks finden
find ~/Documents -type l ! -exec test -e {} \; -print

# Alle harten Links zu einer Datei finden (gleiche Inode)
find / -inum $(stat -f %i datei.txt) 2>/dev/null

Link-Informationen mit stat:

# Inode und Link-Count anzeigen
stat -f "Inode: %i, Links: %l" datei.txt

# Bei Symlinks: Link vs. Ziel
stat -f "Link: %N, Ziel: %Y" ~/Projekte

2 Dateisystem-Tools

2.1 stat – Detaillierte Datei-Informationen

stat zeigt umfassende Metadaten einer Datei an.

Syntax:

stat [Optionen] DATEI

Standardausgabe:

stat ~/.zshrc
# 16777220 8453123 -rw-r--r-- 1 max staff 0 2048 "Jan 15 10:30:00 2024" ...

Formatierte Ausgabe (macOS BSD-stat):

# Lesbare Ausgabe
stat -x ~/.zshrc

# Bestimmte Felder
stat -f "%N: %z Bytes, modified %Sm" ~/.zshrc
# .zshrc: 2048 Bytes, modified Jan 15 10:30:00 2024

# Nur Dateigröße
stat -f %z ~/.zshrc
# 2048

# Nur Inode
stat -f %i ~/.zshrc
# 8453123

# Berechtigungen oktal
stat -f %Op ~/.zshrc
# 100644

# Besitzer und Gruppe
stat -f "%Su:%Sg" ~/.zshrc
# max:staff

Format-Spezifizierer (BSD/macOS):

Beispiele:

# Erstellungsdatum (macOS-spezifisch)
stat -f "Erstellt: %SB" -t "%Y-%m-%d %H:%M" ~/.zshrc

# Vergleich zweier Dateien
for f in file1.txt file2.txt; do
    stat -f "%N: %z Bytes, %Sm" "$f"
done

# Alle Infos für Skript
stat -f "size=%z;inode=%i;mode=%Op;uid=%u;gid=%g" datei.txt

2.2 file – Dateityp erkennen

file analysiert den Inhalt einer Datei und bestimmt ihren Typ – unabhängig von der Dateiendung.

Syntax:

file [Optionen] DATEI...

Beispiele:

file document.pdf
# document.pdf: PDF document, version 1.7

file image.png
# image.png: PNG image data, 1920 x 1080, 8-bit/color RGBA

file script.sh
# script.sh: Bourne-Again shell script, ASCII text executable

file binary
# binary: Mach-O 64-bit executable arm64

file archive.tar.gz
# archive.tar.gz: gzip compressed data

file unknown
# unknown: ASCII text, with very long lines

Optionen:

Anwendungen:

# MIME-Typ für Webserver
file -I document.pdf
# document.pdf: application/pdf; charset=binary

# Mehrere Dateien
file *
# bild.jpg:    JPEG image data
# script.py:   Python script, ASCII text
# data.json:   JSON data

# In Skripten: Typ prüfen
if file -b "$1" | grep -q "shell script"; then
    echo "Ist ein Shell-Skript"
fi

# Nur echte Bilder finden
find . -type f -exec file {} \; | grep "image data"

2.3 mdls – macOS-Metadaten anzeigen

mdls zeigt Spotlight-Metadaten einer Datei an. Diese umfassen weit mehr als Standard-Dateiattribute.

Syntax:

mdls [Optionen] DATEI

Beispiel:

mdls foto.jpg
# kMDItemContentType         = "public.jpeg"
# kMDItemContentTypeTree     = (
#     "public.jpeg",
#     "public.image",
#     "public.data"
# )
# kMDItemDateTimeOriginal    = 2024-01-15 10:30:00 +0000
# kMDItemPixelHeight         = 1080
# kMDItemPixelWidth          = 1920
# kMDItemColorSpace          = "RGB"
# ...

Bestimmte Attribute abfragen:

# Nur bestimmtes Attribut
mdls -name kMDItemContentType foto.jpg
# kMDItemContentType = "public.jpeg"

# Mehrere Attribute
mdls -name kMDItemPixelWidth -name kMDItemPixelHeight foto.jpg

# Wert ohne Attributnamen
mdls -raw -name kMDItemPixelWidth foto.jpg
# 1920

Wichtige Metadaten-Attribute:

Praktische Beispiele:

# Bildabmessungen
mdls -name kMDItemPixelWidth -name kMDItemPixelHeight *.jpg

# Woher wurde Datei heruntergeladen?
mdls -name kMDItemWhereFroms ~/Downloads/installer.dmg

# Dauer eines Videos
mdls -raw -name kMDItemDurationSeconds video.mp4

# Alle PDFs mit Seitenzahl
for f in *.pdf; do
    pages=$(mdls -raw -name kMDItemNumberOfPages "$f" 2>/dev/null)
    echo "$f: $pages Seiten"
done

Metadaten setzen mit xattr:

# Extended Attributes anzeigen
xattr -l datei.txt

# Quarantäne-Flag entfernen (heruntergeladene Dateien)
xattr -d com.apple.quarantine datei.app

# Alle xattrs entfernen
xattr -c datei.txt

3 Volumes & Mounten

3.1 diskutil – Laufwerke verwalten

diskutil ist das zentrale macOS-Tool zur Verwaltung von Festplatten, Partitionen und Volumes.

Laufwerke auflisten:

# Alle Laufwerke
diskutil list

# Ausgabe:
# /dev/disk0 (internal, physical):
#    #:                       TYPE NAME                    SIZE
#    0:      GUID_partition_scheme                        *500.1 GB
#    1:                        EFI EFI                     209.7 MB
#    2:                 Apple_APFS Container disk1         499.9 GB
#
# /dev/disk1 (synthesized):
#    #:                       TYPE NAME                    SIZE
#    0:      APFS Container Scheme -                      +499.9 GB
#    1:                APFS Volume Macintosh HD            12.4 GB
#    2:                APFS Volume Preboot                 23.1 MB
#    ...

Volume-Informationen:

# Detaillierte Infos zu einem Volume
diskutil info /dev/disk1s1

# Infos über Mount-Point
diskutil info /Volumes/USB

# Nur bestimmte Info
diskutil info /dev/disk1s1 | grep "Volume Name"

Volumes ein- und aushängen:

# Volume aushängen
diskutil unmount /Volumes/USB
diskutil unmount /dev/disk2s1

# Volume einhängen
diskutil mount /dev/disk2s1

# Alle Volumes eines Laufwerks aushängen
diskutil unmountDisk /dev/disk2

# Laufwerk sicher auswerfen
diskutil eject /dev/disk2

Partitionen und Formatierung:

# Volume löschen (APFS)
diskutil eraseVolume APFS "NeuesVolume" /dev/disk2s1

# Ganzes Laufwerk formatieren (ACHTUNG!)
diskutil eraseDisk APFS "MeinDisk" /dev/disk2

# Verfügbare Dateisystem-Typen
diskutil listFilesystems

# Partition hinzufügen (APFS Container)
diskutil apfs addVolume disk1 APFS "Daten"

APFS-spezifische Befehle:

# APFS Container auflisten
diskutil apfs list

# Volume zu Container hinzufügen
diskutil apfs addVolume disk1 APFS "NeuesVolume"

# Volume löschen
diskutil apfs deleteVolume disk1s3

# Volume umbenennen
diskutil rename disk1s2 "Neuer Name"

Festplatten reparieren:

# Dateisystem prüfen
diskutil verifyVolume /dev/disk1s1

# Dateisystem reparieren
diskutil repairVolume /dev/disk1s1

# First Aid (GUI-Äquivalent)
diskutil verifyDisk /dev/disk0
diskutil repairDisk /dev/disk0

3.2 mount / umount – Volumes ein-/aushängen

Die klassischen Unix-Befehle mount und umount funktionieren auch unter macOS.

Aktuelle Mounts anzeigen:

# Alle gemounteten Volumes
mount

# Nur bestimmter Typ
mount | grep apfs
mount | grep nfs

# Übersichtlicher mit df
df -h

Volume manuell mounten:

# Mount-Point erstellen
sudo mkdir /Volumes/MeinUSB

# Volume mounten
sudo mount -t msdos /dev/disk2s1 /Volumes/MeinUSB

# Mit Optionen
sudo mount -t hfs -o ro /dev/disk2s1 /Volumes/ReadOnly

Volume aushängen:

# Normal aushängen
sudo umount /Volumes/MeinUSB

# Erzwingen (wenn "busy")
sudo umount -f /Volumes/MeinUSB

# Besser: diskutil verwenden
diskutil unmount /Volumes/MeinUSB

Mount-Optionen:

3.3 Netzlaufwerke mounten (SMB, NFS, AFP)

SMB/CIFS (Windows-Freigaben):

# Mit mount_smbfs
mount_smbfs //user@server/share /Volumes/Share

# Mit Passwort (unsicher, besser Keychain nutzen)
mount_smbfs //user:passwort@server/share /Volumes/Share

# Über Finder-URL (öffnet Finder)
open smb://server/share

# Mount-Point vorbereiten
mkdir -p /Volumes/NAS
mount_smbfs //max@nas.local/Daten /Volumes/NAS

NFS:

# NFS-Mount
sudo mount -t nfs server:/export/share /Volumes/NFS

# Mit Optionen
sudo mount -t nfs -o resvport,rw server:/share /Volumes/NFS

# NFS-Exports auf Server anzeigen
showmount -e server

AFP (Apple Filing Protocol, veraltet):

# AFP-Mount
mount_afp afp://user@server/share /Volumes/AFP

# Über Finder
open afp://server/share

WebDAV:

# WebDAV mounten
mount_webdav https://server/dav /Volumes/WebDAV

Netzlaufwerk per Skript verbinden:

#!/bin/zsh
# mount-nas.sh

SERVER="nas.local"
SHARE="Daten"
USER="max"
MOUNTPOINT="/Volumes/NAS"

# Mount-Point erstellen falls nötig
[-d "$MOUNTPOINT"](-d%20"$MOUNTPOINT".md) || mkdir -p "$MOUNTPOINT"

# Prüfen ob bereits gemountet
if mount | grep -q "$MOUNTPOINT"; then
    echo "Bereits verbunden"
    exit 0
fi

# Mounten (Passwort aus Keychain)
mount_smbfs "//${USER}@${SERVER}/${SHARE}" "$MOUNTPOINT"

if [$? -eq 0]($?%20-eq%200.md); then
    echo "Erfolgreich verbunden: $MOUNTPOINT"
else
    echo "Fehler beim Verbinden"
    exit 1
fi

3.4 /etc/fstab – Automatisches Mounten

Die Datei /etc/fstab definiert Volumes, die beim Systemstart automatisch gemountet werden.

Syntax:

DEVICE  MOUNTPOINT  FSTYPE  OPTIONS  DUMP  PASS