~ $

linux advanced commands

— grep · sed · awk · find · xargs · jq · und mehr

grep — Suchen in Text

Muster suchen
grep "muster" datei
Case-insensitiv
grep -i
Rekursiv in Ordner
grep -r "muster" ./
Zeilennummern anzeigen
grep -n
Invertieren (ohne Treffer)
grep -v
Nur Dateinamen ausgeben
grep -l
N Zeilen Kontext
grep -C 3
Zeilen vor/nach Treffer
grep -B 2 -A 2
Extended Regex
grep -E
Fixed string (kein Regex)
grep -F
Treffer zählen
grep -c
Wort-exakt matchen
grep -w
Nur Treffer ausgeben
grep -o
Mehrere Muster
grep -e "a" -e "b"
Muster aus Datei
grep -f muster.txt

sed — Stream Editor

Ersetzen (erste Stelle)
sed 's/alt/neu/'
Ersetzen (alle Stellen)
sed 's/alt/neu/g'
Case-insensitiv ersetzen
sed 's/alt/neu/gi'
In Datei ersetzen
sed -i 's/alt/neu/g'
Backup beim In-Place
sed -i.bak 's/…/…/g'
Zeile N ausgeben
sed -n '5p'
Zeilen N–M ausgeben
sed -n '2,8p'
Zeile löschen
sed '3d'
Leere Zeilen löschen
sed '/^$/d'
Zeile mit Muster löschen
sed '/muster/d'
Zeile einfügen nach N
sed '3a\neue zeile'
Zeile einfügen vor N
sed '3i\neue zeile'
Nur Treffer-Zeilen
sed -n '/muster/p'
Ersten Buchstaben groß
sed 's/./\u&/'

awk — Text Processing

Spalte N ausgeben
awk '{print $2}'
Letzte Spalte
awk '{print $NF}'
Mehrere Spalten
awk '{print $1,$3}'
Trennzeichen setzen
awk -F':'
Zeilen filtern
awk '/muster/ {print}'
Bedingung auf Spalte
awk '$3 > 100'
Zeilen zählen
awk 'END {print NR}'
Spalte summieren
awk '{s+=$1} END{print s}'
Header überspringen
awk 'NR>1'
BEGIN/END Block
awk 'BEGIN{} {} END{}'
Output-Trennzeichen
awk 'BEGIN{OFS=","}'
printf formatieren
awk '{printf "%s\n",$1}'
Doppelte Zeilen
awk '!seen[$0]++'
Zeile N ausgeben
awk 'NR==5'

find — Dateien suchen

Nach Name suchen
find . -name "*.log"
Case-insensitiv
find . -iname "*.TXT"
Nur Dateien
find . -type f
Nur Ordner
find . -type d
Nach Größe (>10MB)
find . -size +10M
Zuletzt geändert (Tage)
find . -mtime -7
Zuletzt zugegriffen
find . -atime +30
Nach Rechten
find . -perm 644
Tiefe begrenzen
find . -maxdepth 2
Befehl ausführen
find . -exec cmd {} \;
Leere Dateien
find . -empty
Owned by user
find . -user root
Verknüpfen mit AND/OR
find . -name "*.go" -o -name "*.py"
Negieren
find . ! -name "*.go"

xargs — Input als Argumente

Basis
cat list.txt | xargs rm
Platzhalter setzen
xargs -I{} cmd {}
Parallel ausführen
xargs -P 4
N Args pro Aufruf
xargs -n 1
Null-separiert (NUL)
xargs -0
Mit find kombinieren
find . -name "*.log" -print0 | xargs -0 rm
Befehl anzeigen (dry-run)
xargs -t
Interaktiv bestätigen
xargs -p
Max. Länge pro Aufruf
xargs -s 4096
Leere Eingabe ignorieren
xargs -r

sort · uniq · cut · tr

Sortieren
sort datei.txt
Umgekehrt sortieren
sort -r
Numerisch sortieren
sort -n
Nach Spalte N sortieren
sort -k2
Menschenlesbare Größen
sort -h
Doppelte entfernen
sort | uniq
Nur Duplikate zeigen
uniq -d
Vorkommen zählen
uniq -c
Spalte ausschneiden
cut -d',' -f2
Zeichen-Bereich
cut -c1-10
Zeichen ersetzen
tr 'a-z' 'A-Z'
Zeichen löschen
tr -d '\n'
Mehrfache squash
tr -s ' '

Prozesse & System

Alle Prozesse
ps aux
Prozess suchen
ps aux | grep name
Prozess-Baum
pstree -p
PID finden
pgrep nginx
Prozess beenden
kill -9 PID
Alle mit Name beenden
pkill nginx
Offene Dateien
lsof -p PID
Port nutzt was?
lsof -i :8080
Netzwerkverbindungen
lsof -i
Speicherbelegung
free -h
Disk-Verbrauch
df -h
Ordnergröße
du -sh ./
Top N größte
du -ah | sort -rh | head -20
System-Infos
uname -a
Uptime / Load
uptime

jq — JSON verarbeiten

Pretty-print
jq '.' datei.json
Feld extrahieren
jq '.name'
Verschachteltes Feld
jq '.user.email'
Array-Element
jq '.[0]'
Alle Array-Elemente
jq '.[]'
Feld aus Array
jq '.[].name'
Filtern
jq '.[] | select(.age > 18)'
Neues Objekt bauen
jq '{n:.name, a:.age}'
Werte als Array
jq '[.[].name]'
Länge
jq 'length'
Keys ausgeben
jq 'keys'
Raw string (kein JSON)
jq -r '.name'
Kompakt ausgeben
jq -c
Aus Shell-Var
jq --arg k "$var" '.[$k]'

ssh · scp · rsync

Verbinden
ssh user@host
Mit Port
ssh -p 2222 user@host
Mit Key
ssh -i ~/.ssh/key user@host
Port-Forwarding (lokal)
ssh -L 8080:localhost:80 host
Port-Forwarding (remote)
ssh -R 8080:localhost:80 host
Befehl ausführen
ssh user@host 'cmd'
Agent forwarding
ssh -A
Datei kopieren (zu)
scp datei user@host:~/
Datei kopieren (von)
scp user@host:~/datei ./
Rekursiv
scp -r ordner/ user@host:~/
rsync lokal
rsync -av src/ dst/
rsync remote
rsync -avz src/ user@host:dst/
Gelöschte sync
rsync --delete
Dry-run
rsync -n

curl — HTTP Requests

GET Request
curl https://api.example.com
POST mit JSON
curl -X POST -d '{…}' -H 'Content-Type: application/json'
Header setzen
curl -H 'Auth: Bearer token'
Response-Header zeigen
curl -I
Folge Redirects
curl -L
In Datei speichern
curl -o datei.html URL
Dateiname aus URL
curl -O URL
HTTP-Statuscode prüfen
curl -o /dev/null -w "%{http_code}"
Basic Auth
curl -u user:pass
TLS ignorieren
curl -k
Verbose output
curl -v
Zeitlimit
curl --max-time 10
Proxy nutzen
curl -x http://proxy:8080

Pipes · Redirects · Subshells

Pipe
cmd1 | cmd2
Stdout in Datei
cmd > datei
Anhängen
cmd >> datei
Stderr umleiten
cmd 2> error.log
Stdout + Stderr
cmd &> all.log
Stderr nach Stdout
cmd 2>&1
Input aus Datei
cmd < datei
Heredoc
cmd << EOF … EOF
Herestring
cmd <<< "string"
Subshell
$(cmd)
Process Substitution
diff <(cmd1) <(cmd2)
Tee (stdout + Datei)
cmd | tee datei
Nur bei Erfolg
cmd1 && cmd2
Nur bei Fehler
cmd1 || cmd2
Im Hintergrund
cmd &

grep — Regex & Praxis-Beispiele

Wichtige Regex-Zeichen

.Beliebiges Zeichen
^Zeilenanfang
$Zeilenende
*0 oder mehr des Vorigen
+1 oder mehr (ERE: -E)
?0 oder 1 (ERE: -E)
[abc]Zeichenklasse
[^abc]Negierte Klasse
\bWortgrenze
\dZiffer (PCRE: -P)
\wWortzeichen (PCRE)
{n,m}n bis m Wiederholungen

Praxis-Beispiele

# IP-Adressen finden
$ grep -E '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' log.txt

# E-Mail-Adressen
$ grep -E '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,}'

# Zeilen die NICHT mit # beginnen
$ grep -v '^#' config.txt

# Nur Zeilen zwischen zwei Mustern
$ sed -n '/START/,/END/p' datei.txt

# Rekursiv alle .go Fehler
$ grep -rn "error" --include="*.go" .

grep mit Pipeline

# Häufigste IPs im Access-Log
$ grep -oE '^[0-9.]+' access.log \
  | sort | uniq -c | sort -rn | head -10

# HTTP 5xx Fehler zählen
$ grep -cE ' 5[0-9]{2} ' access.log

# Zeilen vor+nach Fehler
$ grep -B2 -A5 "FATAL" app.log

# Git-Log nach Autor filtern
$ git log --oneline \
  | grep -i "fix"

sed — Fortgeschrittene Beispiele

Substitution & Backreferences

# Gruppen mit \1 referenzieren
$ sed 's/\(foo\)\(bar\)/\2\1/'
# foobar → barfoo

# Datum von YYYY-MM-DD zu DD.MM.YYYY
$ sed 's/\([0-9]\{4\}\)-\([0-9]\{2\}\)-\([0-9]\{2\}\)/\3.\2.\1/'

# Nur in Zeilen die "error" enthalten
$ sed '/error/s/foo/bar/g'

# Leerzeichen am Zeilenende trimmen
$ sed 's/[[:space:]]*$//'

# Kommentarzeilen entfernen + Leere
$ sed '/^\s*#/d; /^$/d' config.conf

# Zeilennummern voranstellen
$ sed '=' datei.txt | sed 'N;s/\n/\t/'

Mehrere Befehle & Skript-Modus

# Mehrere -e Ausdrücke
$ sed -e 's/foo/bar/g' -e '/^#/d'

# sed-Skript aus Datei
$ sed -f transforms.sed input.txt

# In allen Dateien eines Ordners
$ find . -name "*.go" \
  -exec sed -i 's/OldName/NewName/g' {} \;

# Zeilen N–M extrahieren (wie head+tail)
$ sed -n '10,20p' large.log

# HTML-Tags entfernen
$ sed 's/<[^>]*>//g' page.html

# Windows CRLF → Unix LF
$ sed -i 's/\r//' datei.txt

awk — Datenverarbeitung & Berichte

Aufbau & Variablen

awk verarbeitet Eingabe Zeile für Zeile. Jede Zeile wird in Felder aufgeteilt ($1, $2, …, $NF). Spezialvariablen:

NRAktuelle Zeilennummer
NFAnzahl Felder in Zeile
FSInput-Trennzeichen
OFSOutput-Trennzeichen
RSRecord-Separator (\n)
ORSOutput-Record-Sep.
FILENAMEAktueller Dateiname
$0Komplette Zeile

Praxis-Beispiele

# CSV: Spalten 1 und 3 ausgeben
$ awk -F',' '{print $1","$3}' data.csv

# Summe einer Spalte
$ awk '{sum+=$2} END{print "Total:", sum}'

# Durchschnitt
$ awk '{s+=$1} END{print s/NR}'

# Duplikate entfernen (Reihenfolge beibehalten)
$ awk '!seen[$0]++' datei.txt

# Zeilen zwischen zwei Mustern
$ awk '/START/{f=1} f; /END/{f=0}'

# Felder umsortieren
$ awk -F':' 'BEGIN{OFS="\t"} {print $3,$1,$6}' /etc/passwd

Log-Analyse Beispiel

# Nginx: Requests pro Status-Code
$ awk '{print $9}' access.log \
  | sort | uniq -c | sort -rn

# Requests pro Stunde
$ awk '{print substr($4,2,14)}' access.log \
  | sort | uniq -c

# Top 10 langsamste Requests
$ awk '{print $NF,$7}' access.log \
  | sort -rn | head -10

# Speichernutzung pro Prozess
$ ps aux | awk 'NR>1 {mem[$11]+=$6}
  END {for(p in mem) print mem[p], p}' \
  | sort -rn | head -10

Power-Kombinationen — Reale Workflows

Dateien & Text

# Alle TODOs im Projekt mit Datei+Zeile
$ grep -rn "TODO" --include="*.go" . \
  | sort -t: -k1,1

# Größte Dateien im Home-Ordner
$ find ~ -type f -size +50M \
  -exec ls -lh {} \; \
  | sort -k5rh

# Alle leeren Ordner löschen
$ find . -type d -empty -delete

# Alle .DS_Store rekursiv löschen
$ find . -name ".DS_Store" -print0 \
  | xargs -0 rm

# Dateien parallel komprimieren
$ find . -name "*.log" -print0 \
  | xargs -0 -P 8 gzip

# JSON-API response verarbeiten
$ curl -s https://api.example.com/users \
  | jq -r '.[].email' \
  | sort | uniq

System & Monitoring

# Port offen? Mit Timeout
$ timeout 3 bash -c "cat < /dev/tcp/host/80" \
  && echo "open" || echo "closed"

# Prozess-CPU alle 2s überwachen
$ watch -n2 'ps aux | sort -k3rn | head -5'

# Log live + nur Fehler
$ tail -f app.log | grep --line-buffered "ERROR"

# Disk-Wachstum beobachten
$ watch -n5 'df -h | grep /dev/sd'

# Netzwerk-Traffic per Interface
$ cat /proc/net/dev \
  | awk 'NR>2 {print $1, "RX:"$2, "TX:"$10}'

# SSH: Remote-Ordner mounten
$ sshfs user@host:/remote/path ~/mountpoint
# Unmount:
$ fusermount -u ~/mountpoint