Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 6: Moderne CLI-Tools

Ziel: Die klassischen Unix-Werkzeuge im Alltag durch schnellere, lesbarere Nachfolger ersetzen, ohne die Klassiker zu verlernen. · Dauer: ca. 75 min · Voraussetzung: Tag 5

Briefing

  • Die neuen Werkzeuge sind Defaults für Menschen: Farbe, .gitignore-Bewusstsein, sinnvolle Voreinstellungen.
  • Die Klassiker (grep, find, cat, ls, diff, top, man, curl) bleiben Pflicht. Sie sind auf jedem Server, in jedem Container und in jedem Skript vorhanden.
  • Faustregel: interaktiv neu, in Skripten klassisch.
  • Alle Werkzeuge kommen aus dem Brewfile (Tag 0). Prüfen: brew bundle check --file=Brewfile.
grep -> rg      find -> fd      cat  -> bat     ls  -> eza
cd   -> z       sed/awk auf JSON/YAML -> jq/yq  diff -> delta
top  -> btop    man  -> tldr    curl -> http (httpie)

Drill 1: ripgrep statt grep

cd ~/term-lab/projekt
grep -rn TODO . | wc -l
rg TODO

Erwartet (Reihenfolge kann variieren):

       7
scripts/report.py
13:# TODO: als JSON ausgeben

internal/cart/cart.go
16: // TODO: Rabatte berücksichtigen

cmd/shop/main.go
13:     port = "8080" // TODO: aus config/app.yaml lesen

grep findet sieben Treffer, vier davon in .git/hooks/*.sample. rg überspringt .git, versteckte Dateien und alles aus .gitignore. Das gilt auch für logs/:

rg -c ERROR; echo "rc=$?"
rg -uu -c ERROR
rg -c ERROR logs

Erwartet:

rc=1
logs/app.log:50
logs/app.log:50

-u hebt .gitignore auf, -uu zusätzlich „versteckt”. Gibst du den Pfad explizit an, sucht rg dort immer.

Die Optionen, die du täglich brauchst:

rg -t go -w port                    # nur Go-Dateien, ganzes Wort
rg -l TODO                          # nur Dateinamen
rg -C1 -t py TODO                   # 1 Zeile Kontext
rg -o -N 'user=u\d+' logs/app.log | sort | uniq -c | sort -rn | head -3

Erwartet (gekürzt):

cmd/shop/main.go
11: port := os.Getenv("PORT")
12: if port == "" {
...
scripts/report.py
12-            counts[parts[2]] += 1
13:# TODO: als JSON ausgeben
14-for level, n in counts.most_common():
  22 user=u16
  22 user=u15
  22 user=u14

Wie viel schneller? Ein großer Ordner, fünf Läufe:

cd /opt/homebrew/Library/Homebrew
hyperfine -N -w 1 -r 5 'grep -rn TODO .' 'rg -n TODO .'
cd ~/term-lab/projekt

Erwartet (gekürzt, abhängig vom Mac):

Benchmark 1: grep -rn TODO . (5 runs)
  Wall Time    803.3 ms  ±    82.5 ms     743.2 ms  …   944.9 ms
Benchmark 2: rg -n TODO . (5 runs)
  Wall Time     25.7 ms  ±     1.3 ms      24.2 ms  …    27.3 ms  -96.8%  (31.3x faster)

Der Vergleich ist nicht ganz fair: rg läuft parallel und lässt Ignoriertes aus. Genau das willst du aber interaktiv fast immer.

Eigene Standardoptionen kommen in eine Datei, auf die RIPGREP_CONFIG_PATH zeigt:

cat > ~/term-lab/config/ripgreprc <<'EOF'
# ripgreprc – eine Option pro Zeile (Tag 6)
--smart-case
--hidden
--glob=!.git/
--max-columns=150
--max-columns-preview
EOF
export RIPGREP_CONFIG_PATH=~/term-lab/config/ripgreprc
rg todo --sort path | head -2

Erwartet:

cmd/shop/main.go
13:     port = "8080" // TODO: aus config/app.yaml lesen

--smart-case: kleingeschrieben sucht ohne Groß/Klein-Unterscheidung, sobald ein Großbuchstabe vorkommt, exakt. --sort path macht die Ausgabe stabil, kostet aber die Parallelität.

Fortschritt speichern? Kostenlos registrieren

Drill 2: fd statt find

find . -name '*.go'
fd -e go
fd yaml
fd -t d

Erwartet:

./cmd/shop/main.go
./internal/cart/cart.go
cmd/shop/main.go
internal/cart/cart.go
config/app.yaml
deploy/k8s/deployment.yaml
cmd/
cmd/shop/
config/
deploy/
deploy/k8s/
docs/
internal/
internal/cart/
scripts/

fd yaml sucht per Regex im Dateinamen, ohne -name '*…*'. Wie rg ignoriert fd versteckte und ignorierte Dateien:

fd -e log; echo "rc=$?"
fd -u -e log
fd -H gitignore

Erwartet:

rc=0
logs/access.log
logs/app.log
.gitignore

Achtung: Ohne Treffer liefert fd trotzdem Exit-Code 0. Für Skripte zählst du die Zeilen.

Befehle auf Treffern ausführen: -x einmal pro Datei (parallel), -X einmal mit allen Dateien:

fd -e go -x wc -l
fd -e yaml -X bat --style=header -r 1:2

Erwartet (Reihenfolge bei -x kann variieren):

      18 ./internal/cart/cart.go
      20 ./cmd/shop/main.go
File: ./deploy/k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment

File: ./config/app.yaml
service: shop
port: 8080

Fortschritt speichern? Kostenlos registrieren

Drill 3: bat statt cat

bat -r 10:14 cmd/shop/main.go

Erwartet:

─────┬──────────────────────────────────────────────────────
     │ File: cmd/shop/main.go
─────┼──────────────────────────────────────────────────────
  10 │ func main() {
  11 │     port := os.Getenv("PORT")
  12 │     if port == "" {
  13 │         port = "8080" // TODO: aus config/app.yaml lesen
  14 │     }
─────┴──────────────────────────────────────────────────────

Im Terminal ist das farbig. bat kennt Git: Geänderte Zeilen bekommen eine Markierung.

echo "  x" >> README.md
bat --style=changes,numbers -r 8:10 README.md
git restore README.md

Erwartet:

   8   - `deploy/k8s` – Manifeste
   9 +   x

Unsichtbare Zeichen (Tabs, Leerzeichen am Zeilenende) sichtbar machen:

printf 'a\tb \n' | bat -A

Erwartet (gekürzt):

   1 │ a├─┤b·␊

├─┤ ist ein Tab, · ein Leerzeichen, ␊ das Zeilenende. Ideal für kaputte YAML-Einrückung.

Tipp: In einer Pipe verhält sich bat wie cat: keine Rahmen, keine Farben. Ein Alias cat=bat bricht deshalb keine Pipes. Dein Kopf muss sich trotzdem merken, dass auf Servern cat wartet.

Fortschritt speichern? Kostenlos registrieren

Drill 4: eza statt ls

eza -l --git --group-directories-first

Erwartet (gekürzt):

drwxr-xr-x@   - du 10 Okt 08:35 -- cmd
drwxr-xr-x@   - du 10 Okt 08:35 -- config
drwxr-xr-x@   - du 10 Okt 08:35 -I logs
drwxr-xr-x@   - du 10 Okt 08:35 -- scripts
.rw-r--r--@  33 du 10 Okt 08:35 -- go.mod
.rw-r--r--@ 260 du 10 Okt 08:35 -- README.md

Die Git-Spalte zeigt den Status: -- unverändert, -M geändert, -I ignoriert, -N neu.

eza --tree --level=2 --git-ignore

Erwartet (gekürzt):

.
├── cmd
│   └── shop
├── config
│   ├── app.json
│   └── app.yaml
├── deploy
│   └── k8s
├── docs
│   └── notizen.txt
...

Jetzt die Aliase dazu. Sie greifen nur, wenn das Werkzeug installiert ist. So bleibt die Konfiguration auf einem Mac ohne eza benutzbar:

cat >> ~/term-lab/config/zsh/aliases.zsh <<'EOF'

# Moderne Werkzeuge (Tag 6), nur wenn installiert
if (( $+commands[eza] )); then
  alias ls='eza --group-directories-first'
  alias ll='eza -l --git --group-directories-first --time-style=relative'
  alias la='eza -la --git --group-directories-first'
  alias lt='eza --tree --level=2 --git-ignore'
fi
(( $+commands[bat] )) && alias cat='bat --paging=never --style=plain'
EOF
reload
ll go.mod

Erwartet:

.rw-r--r--@ 33 du 6 minutes -- go.mod

Die relative Zeit hängt davon ab, wann du Tag 0 gemacht hast.

Fortschritt speichern? Kostenlos registrieren

Drill 5: zoxide statt cd

zoxide merkt sich, wohin du oft und zuletzt springst (Frecency). Danach reicht ein Wortteil. Die Datenbank legst du ins Lab, damit eine echte zoxide-Datenbank unberührt bleibt:

cat > ~/term-lab/config/zsh/tools.zsh <<'EOF'
# tools.zsh – Initialisierung moderner Werkzeuge (Tag 6)

# zoxide: Datenbank im Lab, damit die echte (falls vorhanden) unberührt bleibt
if (( $+commands[zoxide] )); then
  export _ZO_DATA_DIR="$LAB/zoxide"
  mkdir -p "$_ZO_DATA_DIR"
  eval "$(zoxide init zsh)"
fi

# bat als Pager für man-Seiten (mit Syntax-Hervorhebung)
if (( $+commands[bat] )); then
  export MANPAGER="sh -c 'col -bx | bat -l man -p'"
  export MANROFFOPT="-c"
fi

# ripgrep: eigene Optionen in einer Datei
export RIPGREP_CONFIG_PATH="$LAB/config/ripgreprc"
EOF
reload
cd internal/cart; cd ~/term-lab/projekt/deploy/k8s; cd /tmp
z cart && pwd
z k8s && pwd
zoxide query -ls

Erwartet (gekürzt):

/Users/du/term-lab/projekt/internal/cart
/Users/du/term-lab/projekt/deploy/k8s
   8.0 /Users/du/term-lab/projekt/internal/cart
   8.0 /Users/du/term-lab/projekt/deploy/k8s
   4.0 /tmp

zi öffnet eine interaktive Auswahl mit fzf (Tag 7). tools.zsh und ripgreprc liegen auch unter $BUCH/zsh/. z - springt zurück wie cd -. Das Home-Verzeichnis nimmt zoxide nicht auf.

Achtung: zoxide init gehört ans Ende der Konfiguration, weil es einen Hook auf cd setzt. Hier ist das erfüllt: Die Lab-.zshrc lädt config/zsh/*.zsh zuletzt.

Fortschritt speichern? Kostenlos registrieren

Drill 6: jq und yq statt grep auf Strukturen

grep sieht Text, jq sieht JSON:

grep -o '"replicas":[0-9]*' config/app.json
jq -r '.service, .replicas' config/app.json
jq .features config/app.json
jq -c '{service, an: [.features | to_entries[] | select(.value) | .key]}' \
  config/app.json

Erwartet:

"replicas":3
shop
3
{
  "rabatt": false,
  "newsletter": true
}
{"service":"shop","an":["newsletter"]}

yq (von Mike Farah) spricht dieselbe Sprache für YAML. Das braucht jeder, der Kubernetes-Manifeste anfasst:

yq .database.host config/app.yaml
yq '.spec.template.spec.containers[0].image' deploy/k8s/deployment.yaml
yq -o json '.features' config/app.yaml
yq '.spec.replicas = 5' deploy/k8s/deployment.yaml | rg replicas

Erwartet:

db.lab.internal
ghcr.io/example/shop:1.4.2
{
  "rabatt": false,
  "newsletter": true
}
  replicas: 5

Ohne -i schreibt yq nur nach stdout. Die Datei bleibt unverändert. Mit yq -i änderst du sie in place, also nur auf sauberem Git-Stand.

Fortschritt speichern? Kostenlos registrieren

Drill 7: delta statt diff

sed 's/log_level: info/log_level: debug/' config/app.yaml > /tmp/lab-app.yaml
diff -u config/app.yaml /tmp/lab-app.yaml
delta config/app.yaml /tmp/lab-app.yaml

Erwartet (gekürzt, ohne Farben):

@@ -1,6 +1,6 @@
 service: shop
 port: 8080
-log_level: info
+log_level: debug
 database:

config/app.yaml ⟶   tmp/lab-app.yaml
────────────────────────────────────────────────────────────
───┐
1: │
───┘
service: shop
port: 8080
log_level: info
log_level: debug

Im Terminal sind die Zeilen rot und grün hinterlegt, das geänderte Wort ist zusätzlich hervorgehoben. Für Code-Reviews ist die Seitenansicht stark:

git diff main feature/rabatt -- config | delta --side-by-side --width 96

Erwartet (gekürzt):

config/app.yaml
─────────────────────────────────────────────────────────────────────
│  8 │features:                    │  8 │features:
│  9 │  rabatt: false              │  9 │  rabatt: true
│ 10 │  newsletter: true           │ 10 │  newsletter: true

Als Standard-Pager für git diff, git log -p und git show richtest du delta in Tag 10 in der Git-Konfiguration ein.

Fortschritt speichern? Kostenlos registrieren

Drill 8: btop, tldr und httpie im Schnelldurchlauf

btop statt top: Starte btop. Die wichtigsten Tasten:

Taste Wirkung Merkhilfe
f Prozesse filtern filter
k markierten Prozess beenden kill
e Baumansicht an/aus tree
1–4 Boxen CPU/Speicher/Netz/Prozesse ein/aus Nummer der Box
q beenden quit

tldr statt man: Beispiele statt Handbuch. Das Brewfile installiert tlrc, der Befehl heißt tldr.

tldr tar

Erwartet (gekürzt, kann je nach Version abweichen):

  tar

  Archiving utility.

  [c]reate an archive and write it to a [f]ile:

      tar cf path/to/target.tar path/to/file1 path/to/file2 ...

Die echte Manpage bleibt die Referenz. Mit MANPAGER aus tools.zsh ist sie jetzt farbig: man rg.

httpie statt curl: Starte einen Testserver und vergleiche:

python3 -m http.server 8765 >/dev/null 2>&1 &
curl -s -i localhost:8765/config/app.json | head -2
curl -s localhost:8765/config/app.json | jq .port
http :8765/config/app.json
kill %1

Erwartet (http-Teil gekürzt, kann je nach Version abweichen):

HTTP/1.0 200 OK
Server: SimpleHTTP/0.6 Python/3.14.8
8080
HTTP/1.0 200 OK
Content-type: application/json

{
    "features": {
        "newsletter": true,
        "rabatt": false
    },
    "port": 8080,

http formatiert JSON und färbt Header. :8765 ist die Kurzform für localhost:8765. POST mit JSON: http POST :8080/api/cart sku=A1 qty:=2 (= String, := Zahl/JSON).

Fortschritt speichern? Kostenlos registrieren

Shortcut-Tabelle

Alt Neu Merkhilfe
grep -rn x . rg x (-t go, -w, -l, -C1, -uu) ripgrep
find . -name '*.go' fd -e go (-t d, -H, -u, -x, -X) find
cat datei bat datei (-r 10:20, -A, -l yaml) Fledermaus mit Flügeln
ls -la ll, la, lt (eza) long, all, tree
cd pfad/zu/ziel z ziel, zi z wie zoxide
grep auf JSON/YAML jq '.a.b', yq '.a.b' query
diff -u a b delta a b, git diff mit delta Flussdelta
top / man / curl btop / tldr / http tl;dr

Kontrollpunkt

for t in rg fd bat eza zoxide jq yq delta btop; do
  (( $+commands[$t] )) && echo "✔ $t" || echo "✘ $t fehlt"
done
[[ $(alias ll) == *eza* ]] && echo "✔ Alias ll" || echo "✘ Alias ll"
[[ -r $RIPGREP_CONFIG_PATH ]] && echo "✔ ripgreprc" || echo "✘ ripgreprc"
[[ $_ZO_DATA_DIR == $LAB/* ]] && echo "✔ zoxide im Lab" || echo "✘ zoxide-Pfad"
(( $(rg -c TODO | wc -l) == 3 )) && echo "✔ rg ignoriert .git" || echo "✘ rg"
[[ $(yq .port config/app.yaml) == 8080 ]] && echo "✔ yq" || echo "✘ yq"

Erwartet: lauter ✔. Für tldr und http meldet brew bundle check dir, falls sie fehlen.

Challenge

Schreib einen Einzeiler, der prüft, ob replicas in config/app.json und in deploy/k8s/deployment.yaml übereinstimmen. Er gibt ✔ replicas gleich (3) aus oder ✘ app.json=… deployment=….

Hinweis: Lies beide Werte in Variablen und vergleiche mit [[ … == … ]].

Lösung

a=$(jq .replicas config/app.json); b=$(yq .spec.replicas deploy/k8s/deployment.yaml)
[[ $a == "$b" ]] && echo "✔ replicas gleich ($a)" || echo "✘ app.json=$a deployment=$b"

Erwartet:

✔ replicas gleich (3)

Gegenprobe ohne Dateiänderung: Ersetze b=… durch b=$(yq '.spec.replicas = 5 | .spec.replicas' deploy/k8s/deployment.yaml).

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Skripte, Dockerfiles und CI-Jobs nutzen POSIX-Werkzeuge (grep, find, sed). rg, fd und eza gibt es dort meist nicht.
  • jq und yq gehören in CI-Images. Achtung: Es gibt zwei yq (Mike Farah, Go, und kislyuk, Python) mit anderer Syntax. Pinne die Version.
  • rg respektiert .gitignore. Für Audits nach Secrets (rg -uu) oder besser spezialisierte Scanner wie gitleaks nutzen.
  • In Firmennetzen braucht http/curl oft einen Proxy und eigene CA-Zertifikate (HTTPS_PROXY, --verify).
  • Neue Werkzeuge kommen über das Brewfile ins Team. So hat jeder dieselben Versionen (Tag 13).