Buchseiten

Grundlegende Linux-Kommandos

Navigation und Dateisystem

Wildcards / Globbing

Dateien erstellen, kopieren, verschieben, löschen

Dateiinhalte anzeigen

Systeminformationen

Umleitungen und Pipes

cp -u

Grundprinzip

cp kopiert Dateien und Verzeichnisse. Die Option -u steht für update und verändert das Kopierverhaltens grundlegend:

Datei wird nur kopiert, wenn die Quelldatei neuer ist als die Zieldatei – oder wenn die Zieldatei nicht existiert.

cp -u quelle.txt ziel.txt

Warum ist das nützlich?

Ohne -u überschreibt cp immer. Mit -u werden nur wirklich geänderte Dateien kopiert. Das ist ideal für:

• Inkrementelle Backups
• Synchronisation von Verzeichnissen ohne rsync
• Skripte, die nur bei Änderungen reagieren sollen

Alle relevanten cp-Optionen im Überblick

Beispiele

Nur neuere Dateien kopieren

cp -u dokument.txt /backup/dokument.txt

# Ganzes Verzeichnis aktualisierend synchronisieren

cp -ru /home/user/projekt/ /backup/projekt/

# Mit Ausgabe, welche Dateien wirklich kopiert wurden

cp -ruv /home/user/daten/ /mnt/backup/daten/

# Metadaten erhalten und nur Updates kopieren

cp -uap /var/www/ /backup/www/

Wie entscheidet cp -u?

cp -u vergleicht mtime (Modification Time) der Dateien:

Quelldatei-mtime > Zieldatei-mtime  →  KOPIEREN

    Quelldatei-mtime ≤ Zieldatei-mtime  →  ÜBERSPRINGEN     
    Zieldatei existiert nicht           →  KOPIEREN

tac

Grundprinzip

tac ist das Gegenteil von cat und gibt eine Datei zeilenweise in umgekehrter Reihenfolge aus. Der Name ist cat rückwärts gelesen.

tac datei.txt

Enthält datei.txt:

Zeile 1

Zeile 2

Zeile 3

Gibt tac datei.txt aus:

Zeile 3

Zeile 2

Zeile 1

Alle Optionen

Standardverhalten

Ohne Optionen gilt \n (Zeilenumbruch) als Trenner, und tac gibt die letzte Zeile zuerst aus.

Beispiele

Datei umgekehrt ausgeben

tac /var/log/syslog | less

# Letzten Log-Eintrag zuerst sehen

tac /var/log/auth.log | head -20

# Mit eigenem Trennzeichen (statt Zeilenumbruch)

echo "a:b:c:d" | tac -s ":"

# Ausgabe: d:c:b:a:

# Trennzeichen wird VOR dem Datensatz gesetzt (-b)

echo -e "---BLOCK1n---BLOCK2n---BLOCK3" | tac -b -s "---"

# Trennzeichen als Regex (-r), z.B. beliebige Zahl als Trenner

echo "Wort1Wort2Wort3" | tac -r -s "[0-9]"

# Kombiniert mit grep: letzte Fehlerzeile im Log

tac /var/log/syslog | grep -m1 "error"

Skript rückwärts "lesen" (für Debugging)

tac skript.sh

Praktischer Nutzen

• Logs von hinten lesen (neueste Einträge zuerst)
• In Kombination mit head die letzten N Einträge effizient filtern
• Alternative zu tail, wenn man mehr Kontrolle braucht

basename

Grundprinzip

basename entfernt den Verzeichnisteil aus einem Dateipfad und gibt nur den Dateinamen zurück. Optional kann auch eine Dateiendung entfernt werden.

Grundsyntax:

basename PFAD SUFFIX

basename OPTION... PFAD... SUFFIX

Alle Optionen

Beispiele

Nur Dateiname aus Pfad

basename /home/user/dokumente/bericht.pdf

# → bericht.pdf

# Nur Name ohne Endung (Suffix angeben)

basename /home/user/dokumente/bericht.pdf .pdf

# → bericht

basename /usr/bin/python3

# → python3

# In Skript: aktuellen Skriptnamen

SKRIPTNAME=$(basename "$0")

echo "Dieses Skript heißt: $SKRIPTNAME"

# Dateiendung dynamisch entfernen

DATEI="/pfad/zur/datei.tar.gz"

basename "$DATEI" .tar.gz

# → datei

# Mehrere Pfade gleichzeitig (-a)

basename -a /etc/hosts /etc/passwd /etc/shadow

# → hosts

# passwd

# shadow

# Mehrere Pfade Suffix entfernen (-a -s)

basename -a -s .txt /daten/a.txt /daten/b.txt /daten/c.txt

# → a

# b

# c

# In Schleife: alle .sh-Dateien ohne Endung

for f in /skripte/*.sh; do

name=$(basename "$f" .sh)

echo "Verarbeite: $name"

done

# Gegenstück: dirname gibt das Verzeichnis zurück

dirname /home/user/dokumente/bericht.pdf

# → /home/user/dokumente

# Kombination basename dirname

DATEI="/home/user/daten/report.csv"

DIR=$(dirname "$DATEI")

NAME=$(basename "$DATEI" .csv)

echo "Verzeichnis: $DIR"

echo "Dateiname: $NAME"

# → Verzeichnis: /home/user/daten

# → Dateiname: report

Häufiger Einsatz in Skripten

#!/bin/bash

# Skript, das sich selbst benennt und Locks verwendet

PROG=$(basename "$0")

LOCKFILE="/tmp/${PROG}.lock"

if [ -f "$LOCKFILE" ]; then

echo "$PROG läuft bereits!" >&2

exit 1

fi

touch "$LOCKFILE"

trap "rm -f $LOCKFILE" EXIT

echo "$PROG wird ausgeführt..."

Verzeichnisstruktur (FHS)

Filesystem Hierarchy Standard

/ Wurzelverzeichnis (root)
├── /bin Essentielle Programme (ls, bash, echo, cp, mv, rm)
├── /sbin System-Programme (für root: fdisk, mkfs, init)
├── /boot Bootloader, Kernel (vmlinuz, initramfs, grub/)
├── /dev Gerätedateien (sda, tty, null, zero)
├── /etc Globale Konfigurationsdateien
│ ├── fstab Dateisystem-Mountpoints
│ ├── passwd Benutzerdatenbank
│ ├── shadow Passwortdatenbank
│ ├── group Gruppendatenbank
│ ├── hostname Rechnername
│ ├── hosts DNS-Einträge lokal
│ └── sudoers Sudo-Regeln
├── /home Benutzer-Homeverzeichnisse (/home/username)
├── /lib Shared Libraries, Kernelmodule
├── /media Automatische Mountpoints (USB, CD)
├── /mnt Manuelle Mountpoints
├── /opt Optionale Software
├── /proc Virtuelles Dateisystem: Prozesse + Kernel-Info
│ ├── cpuinfo CPU-Informationen
│ ├── meminfo Speicherinformationen
│ └── PID/ Verzeichnis pro Prozess
├── /root Home-Verzeichnis von root
├── /run Runtime-Daten seit letztem Boot
├── /srv Daten für Serverdienste
├── /sys Virtuelles Dateisystem: Hardware + Kernel
├── /tmp Temporäre Dateien (nach Neustart gelöscht)
├── /usr Bibliotheken, Systemtools, installierte Programme
│ ├── /usr/bin Benutzer-Programme
│ ├── /usr/sbin System-Programme
│ └── /usr/lib Bibliotheken
└── /var Variable Daten
├── /var/log Logdateien (syslog, dmesg, auth.log)
├── /var/spool Warteschlangen (Druckjobs, Cron, Mail)
└── /var/tmp Persistente temporäre Dateien

Wichtige Merkmale:

• Keine Laufwerksbuchstaben – stattdessen Mountpoints
• /proc und /sys sind virtuelle Dateisysteme → belegen keinen Speicherplatz
• /proc ändert sich ständig → keine Backups davon erstellen!
• Logdateien: syslog = allgemein, dmesg = Kernel-Log
• Ansehen: cat /var/log/syslog oder less /var/log/syslog

Zusammenfassung: Die /etc/sudoers Datei

• Zentrale Konfigurationsdatei für sudo
• Legt fest welche Benutzer welche Berechtigungen auf welchen Hosts haben
• Darf nicht mit normalem Texteditor geöffnet werden
  • Immer visudo: Prüft Syntax auf Fehler

Struktur

• Festes Muster: User Host=(RunAsUser:RunAsGroup) Commands
  • User: Der Benutzer oder die Gruppe (Gruppen werden mit % gekennzeichnet), der die Berechtigung erhält.
  • Host: Der Hostname, auf dem die Regel gilt (meist ALL für alle Rechner).
  • RunAsUser: Der Benutzer, als der der Befehl ausgeführt werden soll (meist root oder ALL).
  • RunAsGroup: Die Gruppe, als die der Befehl ausgeführt werden soll (meist ALL).
  • Commands: Die Liste der erlaubten Befehle (absolute Pfade verwenden!).

Praktische Beispiele

A. Vollzugriff (Administrator-Status)

Erlaubt einem Benutzer alle Befehle mit Root-Rechten (erfordert Passwort).

Benutzer 'max' darf alles

max ALL=(ALL:ALL) ALL

# Gruppe 'admin' darf alles (beachte das %)
%admin ALL=(ALL:ALL) ALL

B. Spezifische Befehle erlauben

Einschränkung auf nur einen einzigen Befehl (sehr wichtig für Sicherheit!).

'devuser' darf nur den Apache-Webserver neu starten

devuser ALL=(ALL) /usr/bin/systemctl restart apache2

C. Ausführung ohne Passwort (NOPASSWD)

Nützlich für Skripte oder Automatisierungen, aber ein Sicherheitsrisiko.

'automation-user' darf Updates machen, ohne nach einem Passwort gefragt zu werden

automation-user ALL=(ALL) NOPASSWD: /usr/bin/apt-get update, /usr/bin/apt-get upgrade

D. Verwendung von Pfaden und Wildcards

Erlaubt das Ausführen von Backup-Skripten im Verzeichnis /opt/scripts/

backup-user ALL=(ALL) /opt/scripts/*.sh

Best Practices & Sicherheit

Principle of Least Privilege (Prinzip der geringsten Berechtigung): Erteile nur so viele Rechte, wie absolut notwendig sind. Vermeide ALL=(ALL) ALL für normale Benutzer.

Absolute Pfade nutzen: Gib Befehle immer mit ihrem vollständigen Pfad an (z. B. /usr/bin/apt statt nur apt), um "Path Injection" Angriffe zu verhindern.

Modularität nutzen (/etc/sudoers.d/): Anstatt die Hauptdatei /etc/sudoers zu verändern, erstelle separate Dateien im Verzeichnis /etc/sudoers.d/. Das ist sauberer und weniger fehleranfällig bei Systemupdates.

Beispiel: sudo visudo -f /etc/sudoers.d/mein-projekt

Gruppen statt Einzeluser: Nutze Gruppen (%gruppe), um die Verwaltung einfacher zu machen. Wenn ein neuer Admin dazukommt, musst du nur die Gruppe ändern, nicht die sudoers-Datei.

Kurzübersicht der Platzhalter

Prinizipien

Das Letzte gewinnt. (The Last Match Wins)

Die sudoers-Datei wird von oben nach unten (sequenziell) eingelesen. Wenn eine Regel auf einen Benutzer zutrifft, werden die Berechtigungen geladen. Wenn eine weitere Regel weiter unten in der Datei ebenfalls auf denselben Benutzer zutrifft, wird diese neue Regel auf die bisherigen Regeln aufgeschlagen oder sie überschreibt spezifische Teile der vorherigen Regeln.

Hier ist die detaillierte Aufschlüsselung, wie sich das in verschiedenen Szenarien verhält:

1. Das Prinzip der Addition (Kumulativ)

Wenn zwei Regeln unterschiedliche Befehle erlauben, werden sie einfach kombiniert. Der Benutzer erhält die Summe aller erlaubten Befehle.

Beispiel:

Regel 1 (oben)

max ALL=(ALL) /usr/bin/apt-get

# Regel 2 (weiter unten)
max ALL=(ALL) /usr/bin/systemctl

Ergebnis: max darf sowohl apt-get als auch systemctl ausführen. Es gibt hier keinen "Verlust", sondern eine Erweiterung.

2. Das Prinzip der Überschreibung (Override)

Ein Konflikt entsteht wirklich erst, wenn sich die Parameter (wie NOPASSWD oder der RunAsUser) für den gleichen Befehl widersprechen. In diesem Fall überschreibt die letzte gefundene Regel die vorherige.

Beispiel (Das Passwort-Dilemma):

Regel 1: Erlaubt alles ohne Passwort

max ALL=(ALL) NOPASSWD: ALL

# Regel 2: Erlaubt spezifisch apt-get, aber ERZWINGT ein Passwort
max ALL=(ALL) /usr/bin/apt-get

Ergebnis: Wenn max versucht, apt-get auszuführen, wird er nach einem Passwort gefragt. Obwohl Regel 1 "alles ohne Passwort" erlaubt hat, hat die spätere Regel 2 die Anweisung für apt-arg mit der Passwort-Pflicht überschrieben.

3. Konflikte durch Gruppen vs. Benutzer (Spezifisch schlägt Generell)

Oft ist ein Benutzer Mitglied einer Gruppe (z. B. %admin). Hier greifen zwei Regeln gleichzeitig: die Gruppenregel und die Benutzerregel.

Beispiel:

Regel 1: Die Gruppe 'admin' darf alles, aber MIT Passwort

%admin ALL=(ALL) ALL

# Regel 2: Der Benutzer 'max' (ist Mitglied von admin) darf alles OHNE Passwort
max ALL=(ALL) NOPASSWD: ALL

Ergebnis: Da die Regel für max spezifischer ist und nach der Gruppenregel kommt, gewinnt die NOPASSWD-Einstellung für ihn. Er kann Befehle ohne Passwort ausführen, während andere Mitglieder der Gruppe admin weiterhin nach einem Passwort gefragt werden.

4. Besonderheit: /etc/sudoers.d/

Das Verzeichnis /etc/sudoers.d/ wird am Ende der Haupt-sudoers-Datei per #includedir eingebunden.

Das bedeutet: Alles, was in den Dateien im sudoers.d-Ordner steht, hat Vorrang vor den Einträgen in der Haupt-sudoers-Datei, weil diese Dateien technisch gesehen "ganz unten" in der Konfigurationskette gelesen werden.

Pro-Tipp für die Praxis: Wenn du eine Berechtigung für einen Benutzer in der Hauptdatei einschränken willst, musst du diese Einschränkung in einer Datei innerhalb von /etc/sudoers.d/ platzieren, damit sie die (eventuell mächtigeren) Regeln aus der Hauptdatei überschreibt.

Zusammenfassung

Dateien suchen: find, grep, sed

find – Dateien und Verzeichnisse suchen

find START_PFAD OPTIONEN AUSDRUCK

Wichtige Optionen:

Beispiele:

Alle .txt Dateien im aktuellen Verzeichnis

find . -name "*.txt" -type f

# Dateien mit Inhalt durchsuchen

find . -type f -exec grep "suchbegriff" '{}'

-print

Dateien älter als 30 Tage löschen

find /home/user/logs/ -type f -mtime 30 -exec rm {}

# Leere Dateien im Home finden

find ~ -empty

grep – In Textdateien suchen

grep [OPTIONEN] ‘MUSTER‘ DATEI

Wichtige Optionen:

Reguläre Ausdrücke für grep:

Beispiele:

Zeilen die mit "König" beginnen

grep "^König" datei.txt

# Zeilen die mit "zz" enden

grep "zz$" datei.txt

# Case-insensitive Suche

grep -i "suchbegriff" datei.txt

# In /etc/passwd nach Bash-Benutzern suchen

grep "/bin/bash" /etc/passwd

sed – Stream Editor

Grundprinzip

sed (Stream Editor) bearbeitet Text zeilenweise. Es liest stdin oder Dateien, wendet Transformationsregeln an und schreibt das Ergebnis nach stdout.

Grundsyntax:

sed 'BEFEHL' datei

sed -e 'BEFEHL1' -e 'BEFEHL2' datei

Alle Kommandozeilen-Optionen

sed-Befehle (innerhalb des Skripts)

Adressen (Adressierung von Zeilen)

sed '3 d' # Nur Zeile 3 löschen

sed '3,7 d' # Zeilen 3-7 löschen

sed '/muster/ d' # Zeilen löschen, die Muster enthalten

sed '3,/ende/ d' # Ab Zeile 3 bis zur Zeile mit "ende"

sed '$ d' # Letzte Zeile löschen

sed '1~2 d' # Jede 2. Zeile löschen (ab Zeile 1): 1,3,5,...

sed '0~2 d' # Gerade Zeilen löschen: 2,4,6,...

Reguläre Ausdrücke in sed

Beispiele

Einfaches Ersetzen

sed 's/alt/neu/' datei.txt

# Alle Vorkommen ersetzen

sed 's/alt/neu/g' datei.txt

# Groß-/Kleinschreibung ignorieren

sed 's/fehler/FEHLER/gi' datei.txt

# Datei direkt bearbeiten (in-place)

sed -i 's/alt/neu/g' datei.txt

# Backup erstellen und in-place bearbeiten

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

# (erstellt datei.txt.bak als Sicherung)

# Zeilen löschen, die "kommentar" enthalten

sed '/kommentar/d' datei.txt

# Leerzeilen löschen

sed '/^$/d' datei.txt

# Leerzeilen und Zeilen mit nur Leerzeichen löschen

sed '/^s*$/d' datei.txt

# Kommentarzeilen (# am Anfang) entfernen

sed '/^#/d' datei.txt

sed '/^[[:space:]]*#/d' datei.txt

# Nur Zeilen ausgeben, die "Muster" enthalten (-n p)

sed -n '/muster/p' datei.txt

# Leerzeichen am Zeilenende entfernen

sed 's/[[:space:]]*$//' datei.txt

# Führende Leerzeichen entfernen

sed 's/^[[:space:]]*//' datei.txt

# Beides (trim)

sed 's/^[[:space:]]//; s/[[:space:]]$//' datei.txt

# Zeilen 5-10 ausgeben

sed -n '5,10p' datei.txt

# Erste Zeile löschen (Header entfernen)

sed '1d' datei.txt

# Letzte Zeile löschen

sed '$d' datei.txt

# Zeilenumbruch nach ";" einfügen (Erweiterter Regex)

sed -E 's/;/;n/g' datei.txt

# Rückreferenz: Wort in Anführungszeichen einschließen

sed 's/(Wort)/"1"/' datei.txt

sed -E 's/(Wort)/"1"/' datei.txt # ERE-Variante

# Text nach Zeile 3 einfügen

sed '3aDies ist eine neue Zeile' datei.txt

# Text vor Zeile 3 einfügen

sed '3iDies kommt davor' datei.txt

# Zeile 3 ersetzen

sed '3cDiese Zeile ersetzt die alte' datei.txt

# Mehrere Befehle (mit -e oder Semikolon)

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

sed 's/foo/bar/g; s/baz/qux/g' datei.txt

# Skript aus Datei

sed -f mein_skript.sed datei.txt

# Nur erste Zeile ausgeben (wie head -1)

sed -n '1p' datei.txt

# Zeilenanzahl begrenzen (wie head -5)

sed '5q' datei.txt

# Zeichenersatz (y-Befehl): Kleinbuchstaben → Großbuchstaben

sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' datei.txt

# Zeilennummern anzeigen (= gibt Nummer aus, p gibt Zeile aus)

sed '=' datei.txt | sed 'N; s/n/t/'

# HTML-Tags entfernen

sed 's/<[^>]*>//g' seite.html

# DOS-Zeilenenden (rn) in Unix (n) umwandeln

sed 's/r//' datei.txt

cut – Spalten extrahieren

5. Feld aus /etc/passwd (Delimiter: Doppelpunkt)

cut -d: -f5 /etc/passwd

# 3. Spalte einer CSV-Datei

cut -d, -f3 datei.csv

awk – Textverarbeitung

Grundprinzip

awk ist eine vollständige Programmiersprache für Textverarbeitung. Es liest Dateien oder Streams zeilenweise, teilt jede Zeile in Felder auf und wendet ein Programm darauf an.

Grundsyntax:

awk 'MUSTER { AKTION }' datei

Felder und Variablen

Kommandozeilen-Optionen

Besondere Blöcke

BEGIN { ... } # Wird einmal VOR dem Einlesen ausgeführt

END { ... } # Wird einmal NACH dem letzten Datensatz ausgeführt

/Muster/ { ... } # Wird für jede Zeile ausgeführt, die Muster enthält

Vergleichsoperatoren

Arithmetik und Strings

Arithmetik

$3 + $4 # Addition

$3 * 1.19 # Multiplikation

int($1 / 2) # Ganzzahldivision

String-Funktionen

length($0) # Länge der Zeile

substr($1, 2, 4) # Teilstring ab Position 2, Länge 4

split($1, arr, ":") # Splitten in Array

gsub(/alt/, "neu") # Globale Ersetzung in $0

sub(/alt/, "neu") # Erste Ersetzung in $0

toupper($1) # Großbuchstaben

tolower($1) # Kleinbuchstaben

index($1, "suche") # Position des Teilstrings

match($0, /regex/) # Regex-Match, setzt RSTART/RLENGTH

sprintf("%.2f", $3) # Formatierte Ausgabe

Beispiele

Alle Zeilen ausgeben (wie cat)

awk '{ print }' datei.txt

awk '{ print $0 }' datei.txt

# Nur das erste Feld ausgeben

awk '{ print $1 }' datei.txt

# Spalten 1 und 3, durch Tab getrennt

awk '{ print $1, $3 }' datei.txt

# Mit Doppelpunkt als Trennzeichen (/etc/passwd)

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

# Benutzernamen und Shell ausgeben

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

# Nur Zeilen mit mehr als 3 Feldern

awk 'NF > 3' datei.txt

# Zeilen die "error" enthalten

awk '/error/ { print }' /var/log/syslog

# Zeilen die NICHT "debug" enthalten

awk '!/debug/' /var/log/syslog

# Zeilennummer mit ausgeben

awk '{ print NR": "$0 }' datei.txt

# Nur Zeile 5 bis 10

awk 'NR>=5 && NR<=10' datei.txt

# Summe der dritten Spalte

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

# Durchschnitt

awk '{ sum += $3 } END { print "Avg:", sum/NR }' zahlen.txt

# Anzahl Zeilen zählen (wie wc -l)

awk 'END { print NR }' datei.txt

# Duplikate entfernen (wie uniq, aber nicht sortiert)

awk '!seen[$0]++' datei.txt

# Leerzeilen entfernen

awk 'NF > 0' datei.txt

awk '/^./' datei.txt

# Felder vertauschen (1. und 2. Spalte tauschen)

awk '{ print $2, $1 }' datei.txt

# Ausgabe-Feldtrenner setzen (Komma)

awk 'BEGIN{OFS=","} { print $1,$2,$3 }' datei.txt

# Variablen von außen übergeben

awk -v grenze=100 '$3 > grenze { print }' datei.txt

# if/else in awk

awk '{ if ($3 > 50) print "groß:", $1; else print "klein:", $1 }' datei.txt

# for-Schleife

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

# Arrays verwenden

awk '{ count[$1]++ } END { for(k in count) print k, count[k] }' log.txt

# Nur die letzte Zeile

awk 'END { print }' datei.txt

# Mehrzeiliger awk-Code aus Datei ausführen

awk -f programm.awk datei.txt

# CSV-Datei auswerten (Komma als Trenner, Anführungszeichen ignorieren)

awk -F'","' '{ print $2 }' daten.csv

# Zwischen zwei Mustern ausgeben (inkl.)

awk '/START/,/STOP/' datei.txt

# BEGIN und END

awk 'BEGIN { print "=== Start ===" } { print } END { print "=== Ende ===" }' datei.txt

# Prozesse nach CPU-Nutzung filtern (ps aux)

ps aux | awk '$3 > 1.0 { print $1, $2, $3, $11 }'

# IP-Adressen aus Logdatei extrahieren

awk '{ match($0, /[0-9]+.[0-9]+.[0-9]+.[0-9]+/, arr); print arr[0] }' access.log

# /etc/passwd – UIDs über 1000 (normale User)

awk -F: '$3 >= 1000 { print $1, $3 }' /etc/passwd

# Größe einer Datei (du-Ausgabe aufsummieren)

du -sh * | awk '{ sum += $1 } END { print sum }'

apt (High-Level – empfohlen!)

Paketquellen: /etc/apt/sources.list

deb http://server.example.com/debian distribution component1 component2

deb-src http://server.example.com/debian distribution component1 component2

- deb = vorcompilierte Binary-Pakete

• deb = vorcompilierte Binary-Pakete
• deb-src = Source-Pakete
• Weitere Quellen in: /etc/apt/sources.list.d/*.list

Benutzer- und Gruppenverwaltung

Arten von Benutzern

Wichtige Konfigurationsdateien

/etc/passwd – Benutzerdatenbank

Username:Password:UID:GID:Info:Home:Shell

• Password = x bedeutet: Passwort steht in /etc/shadow
• Beispiel: bob❌1001:1001:Bob Miller:/home/bob:/bin/bash

/etc/shadow – Passwortdatenbank

Username:Password:DOC:MinD:MaxD:Warn:Exp:Dis

• DOC = Tag der letzten Passwortänderung (ab 1.1.1970)
• Editieren mit: vipw -s

/etc/group – Gruppendatenbank

Gruppenname:Passwort:GID:Mitgliederliste

/etc/skel – Vorlage für neue Benutzer

• Dateien aus diesem Verzeichnis werden bei useradd -m ins neue Home kopiert

Befehle zur Gruppenverwaltung

Befehle zur Benutzerverwaltung

Zugriffsrechte und Dateiberechtigungen

Aufbau der Berechtigungen

-rwxr-xr-- 1 besitzer gruppe größe datum dateiname
│├─┤├─┤├─┤
│ │ │ └── Andere (Others): r--
│ │ └────── Gruppe (Group): r-x
│ └────────── Besitzer (User): rwx
└──────────── Dateityp: - = Datei, d = Verzeichnis

Bedeutung der Rechte

chmod – Rechte ändern

Symbolische Methode:

chmod u+x datei.sh # User: Ausführen hinzufügen

chmod g-w datei.txt # Gruppe: Schreiben entfernen

chmod o=r datei.txt # Andere: Nur Lesen

chmod a+x skript.sh # Alle: Ausführen hinzufügen

chmod u=rwx,g=rx,o= datei # Explizit setzen

Oktalnotation:

chmod 755 datei # rwxr-xr-x

chmod 644 datei # rw-r--r--

chmod 700 datei # rwx------

chmod 000 datei # ---------

Häufige Berechtigungssätze:

chown / chgrp – Besitzer/Gruppe ändern

chown benutzer:gruppe datei # Besitzer und Gruppe ändern

chown benutzer datei # Nur Besitzer ändern

chgrp gruppe datei # Nur Gruppe ändern

Spezialberechtigungen

SetUID – Detailbeschreibung

• Gesetzt auf eine ausführbare Datei: Programm läuft immer mit der UID des Datei-Eigentümers, egal welcher Benutzer es startet
• Klassisches Beispiel: /usr/bin/passwd → muss /etc/shadow (Besitzer: root) schreiben, darf aber von jedem Benutzer aufgerufen werden
• Auf Verzeichnisse: In den meisten Linux-Distros keine Wirkung
• Sicherheitsrisiko: SetUID-root-Programme sind ein beliebtes Angriffsziel (Privilege Escalation)

chmod u+s /usr/bin/meinprog # SetUID setzen

chmod 4755 /usr/bin/meinprog # Oktal: 4 + 755

SetGID – Detailbeschreibung

• Gesetzt auf eine ausführbare Datei: Programm läuft mit der GID des Datei-Eigentümers
• Gesetzt auf ein Verzeichnis: Alle neu erstellten Dateien und Unterverzeichnisse erben automatisch die Gruppe des Verzeichnisses (sehr nützlich für Team-Ordner!)

chmod g+s /srv/team/ # SetGID auf Verzeichnis

chmod 2755 /srv/team/ # Oktal: 2 + 755

Sticky Bit – Detailbeschreibung

• Gesetzt auf ein Verzeichnis: Jeder kann Dateien erstellen, aber nur der Eigentümer der Datei (oder root) darf diese löschen/umbenennen
• Wichtigstes Beispiel: /tmp – alle Benutzer können dort Dateien anlegen, aber niemand darf fremde Dateien löschen
• Auf Dateien: Historisch bedeutete es „Programm im Swap behalten" – heute in Linux keine Funktion mehr

chmod +t /tmp/gemeinsam/ # Sticky Bit setzen

chmod 1777 /tmp/ # Oktal: 1 + 777 ← Typisch für /tmp

Verifizieren:

ls -ld /tmp

# drwxrwxrwt → das 't' am Ende = Sticky Bit gesetzt

stat /tmp

Vollständige Übersicht: Was ls -l bei Berechtigungen anzeigt

Das Berechtigungsfeld hat 10 Zeichen: 1 Dateityp + 3×3 Rechte (user/group/others)

Position: 1 234 567 890
│ ├─┤ ├─┤ ├─┤
Beispiel: d rwx r-s r-t
│ │ │ │
│ │ │ └── Others
│ │ └──────── Group
│ └────────────── User
└─────────────────── Dateityp

Position 1: Dateityp

Positionen 2–4 (User), 5–7 (Group), 8–10 (Others): Basisrechte

Position 4 (User), 7 (Group), 10 (Others): Spezialbit-Überlagerung

Merkregel: Kleinbuchstabe (s, t*) = Spezialbit* UNDx**. Großbuchstabe (S, T*) = Spezialbit* OHNEx**.

Alle möglichen Zeichen auf einen Blick

Dateityp: - d l b c p s

User: r w x s S
Group: r w x s S
Others: r w x t T
(- für jeweils "nicht gesetzt")

Praxisbeispiele mit ls -l

Oktalwerte der Spezialbits

Spezialberechtigungen prüfen:

Alle SetUID-Dateien auf dem System finden:

find / -perm -4000 -type f 2>/dev/null

# Alle SetGID-Dateien finden:

find / -perm -2000 -type f 2>/dev/null

# Alle Verzeichnisse mit Sticky Bit:

find / -perm -1000 -type d 2>/dev/null

# Detailansicht mit stat:

stat /tmp

stat /usr/bin/passwd

umask – Standard-Berechtigungen

umask (user file creation mask) legt fest, welche Rechte beim Erstellen neuer Dateien und Verzeichnisse weggenommen werden. Es ist eine Maske, keine direkte Rechtevergabe.

Berechnung

Neue Rechte = Maximalrechte - umask

Warum haben Dateien maximal 666?
Linux vergibt niemals automatisch das execute-Bit (x) auf neue Dateien, da eine normale Datei kein Programm ist. Verzeichnisse brauchen x um betreten werden zu können, daher Maximal 777*.*

Wichtiger Hinweis zur Berechnung

Die Subtraktion ist bitweise (nicht arithmetisch):

Beispiel: umask 027

Datei: 666 (rw-rw-rw-)

umask: 027 (----w-rwx) → wird weggenommen

Ergebnis: 640 (rw-r-----)

Verzeichnis:

Verzeichnis: 777 (rwxrwxrwx)

umask: 027 (----w-rwx) → wird weggenommen

Ergebnis: 750 (rwxr-x---)

Alle wichtigen umask-Werte

Befehle

umask # Aktuelle umask anzeigen (oktal)
umask -S # Symbolische Anzeige (z.B. u=rwx,g=rx,o=rx)
umask 022 # umask für aktuelle Shell-Sitzung setzen
umask 027 # Strengere umask setzen

umask dauerhaft setzen

In ~/.bashrc eintragen:

umask 022

Praxisbeispiel: Warum umask wichtig ist

Ohne umask 022 (Standard):

touch neue_datei.txt → -rw-r--r-- (644)

mkdir neuer_ordner/ → drwxr-xr-x (755)

# Mit umask 077 (privat):

umask 077

touch geheime_datei.txt → -rw------- (600)

mkdir privater_ordner/ → drwx------ (700)

Umgebungsvariablen

Wichtige Standard-Variablen

Variablen anzeigen/setzen

echo $HOME # Variable ausgeben

env # Alle Umgebungsvariablen anzeigen

printenv # Alternative

set # Alle Variablen Funktionen

# Variable setzen (nur lokal/aktuelle Shell)

myvar="Hallo"

# Variable exportieren (für Kindprozesse)

export myvar="Hallo"

# Variable löschen

unset myvar

# PATH erweitern

export PATH="/home/user/bin:$PATH"

Quoting-Regeln

Prozessmanagement und Systemüberwachung

Prozess-Grundlagen

• Ein Prozess = ein Programm in Ausführung
• Jeder Prozess hat: PID (Prozessnummer), PPID (Elternprozess-ID), Benutzer
• PID 1 = erster Prozess (/sbin/init bzw. systemd)

Prozesszustände

Befehle zur Prozessverwaltung

Vorder- und Hintergrundprozesse

Prozesspriorität (nice-Wert)

nice -n 10 kommando # Programm mit niedrigerer Priorität starten

nice -n -10 kommando # Höhere Priorität (nur root)

renice 5 -p PID # Priorität eines laufenden Prozesses ändern

Systemüberwachung

Das /proc-Verzeichnis

Jeder Prozess hat ein Verzeichnis /proc/PID/:

/proc/
├── PID/
│ ├── cmdline → Befehl
│ ├── cwd → Link zum Arbeitsverzeichnis
│ ├── exe → Link zum Programm
│ └── status → Statusinformationen
├── meminfo → Speicherinfo
└── cpuinfo → CPU-Info

Systemstart: Init-Systeme

Bootvorgang (Überblick)

BIOS/UEFI → GRUB Bootloader → Kernel + initramfs laden
→ Root-Dateisystem mounten → init/systemd starten
→ Systemdienste laden → Benutzeranmeldung

Ablauf

1. Bootloader: Kernel und initramfs in RAM laden
2. Kernel laden: Hardware wird initialisiert
3. InitRamFS: Temporäres Root-Dateisystem zum laden von Modulen und Zugriff aufs echte FS
4. Mount Root FS: Kernel mountet Dateisystem nach /etc/fstab
5. Init starten: Erstes Prozessprogramm wird ausgeführt (init/systemd)
6. Dienste starten
7. Boot abgeschlossen: Bereit zur Anmeldung

sysinit vs. systemd – Vergleich

systemd-Dienstverwaltung

systemctl – Dienste verwalten

journalctl – Logging

systemd Unit-Dateien

Speicherorte:

• /usr/lib/systemd/system/ – Standard-Units (vom Paketmanager)
• /etc/systemd/system/ – Eigene/überschriebene Units (höhere Priorität)

Aufbau einer Service-Unit:

Unit

Description=Mein Beispielservice

Requires=network.target # Harte Abhängigkeit

After=network.target # Startreihenfolge

Wants=redis.service # Weiche Abhängigkeit

Service

Type=simple

ExecStart=/usr/bin/python3 /opt/app/server.py

ExecStop=/bin/kill -SIGTERM $MAINPID

User=nobody

Restart=on-failure

RestartSec=3

StartLimitBurst=4

StartLimitIntervalSec=30

WorkingDirectory=/opt/app/

# Sicherheitshärtung:

PrivateTmp=true # Isoliertes /tmp

ProtectSystem=full # System read-only

ProtectHome=true # Kein Zugriff auf /home

NoNewPrivileges=true # Keine Privileg-Eskalation

# Ressourcenlimits:

MemoryMax=200M

CPUQuota=20%

TasksMax=100

Install

WantedBy=multi-user.target # Beim Boot starten

Unit aktivieren und starten:

sudo systemctl daemon-reload

sudo systemctl enable mein.service

sudo systemctl start mein.service

Systemanalyse

systemd-analyze blame # Bootzeit pro Dienst

systemd-analyze critical-chain # Kritischer Pfad

systemd-analyze plot >boot.svg # Visualisierung

systemd-analyze verify dienst.service # Syntax prüfen

cron

Grundprinzip

cron ist ein Dienst (Daemon) zum zeitgesteuerten Ausführen von Befehlen. Die Aufgaben werden in der crontab (cron table) definiert.

crontab -e # Eigene crontab bearbeiten

crontab -l # Eigene crontab anzeigen

crontab -r # Eigene crontab löschen

crontab -u user -e # crontab eines bestimmten Benutzers bearbeiten (root)

Das Zeitformat (5-Felder-Cron)

┌──────────── Minute (0 - 59)
│ ┌────────── Stunde (0 - 23)
│ │ ┌──────── Tag (Monat) (1 - 31)
│ │ │ ┌────── Monat (1 - 12 oder jan,feb,...)
│ │ │ │ ┌──── Wochentag (0 - 7, 0 und 7 = Sonntag, oder sun,mon,...)
│ │ │ │ │

• • • • • Befehl

Sonderzeichen in cron

Das / (Slash / Schrittweite) – ausführlich erklärt

Der Slash definiert eine Schrittweite innerhalb eines Wertebereichs.

BEREICH/SCHRITT

• */4 im Minutenfeld: „Von 0 bis 59, jeden 4. Wert" → Minute 0, 4, 8, 12, 16, 20, ...56
• 0/4 im Minutenfeld: „Starte bei 0, dann alle 4" → Minute 0, 4, 8, 12, ...56 (identisch zu */4)
• 2/4 im Minutenfeld: „Starte bei 2, dann alle 4" → Minute 2, 6, 10, 14, ...58
• 10-30/5 im Minutenfeld: „Von 10 bis 30, alle 5" → Minute 10, 15, 20, 25, 30

Fazit: 0/4 und */4 sind im Minutenfeld identisch, da * für 0-59 steht und 0/4 explizit bei 0 startet.

Das 6-Felder-Format (Quartz/Spring)

Manche Systeme (Java Quartz Scheduler, Spring Boot Cron, manche DevOps-Tools) verwenden ein 6-Felder-Format mit Sekunden:

┌────────────── Sekunde (0 - 59)
│ ┌──────────── Minute (0 - 59)
│ │ ┌────────── Stunde (0 - 23)
│ │ │ ┌──────── Tag (Monat) (1 - 31)
│ │ │ │ ┌────── Monat (1 - 12)
│ │ │ │ │ ┌──── Wochentag (0 - 7)
│ │ │ │ │ │

• • • • • • Befehl

0/4 * * * * * (6 Felder, Quartz-Format):

• Sekunden-Feld: 0/4 → Starte bei Sekunde 0, alle 4 Sekunden → 0, 4, 8, 12, ...56
• Alle anderen Felder: * → immer
• Bedeutung: Alle 4 Sekunden, jede Minute, jede Stunde, jeden Tag...

Wichtig: Standard-Linux-cron (Vixie Cron, cronie) verwendet 5 Felder ohne Sekunden. Die 6-Felder-Variante ist bei systemd-Timer oder Spring @Scheduled üblich.

Vordefinierte Makros (nur 5-Felder-cron)

Beispiele

Jede Minute

• • • • • /skript.sh

Alle 5 Minuten

*/5 * * * * /skript.sh

Alle 4 Minuten (ab Minute 0)

0/4 * * * * /skript.sh

oder äquivalent:

*/4 * * * * /skript.sh

Alle 4 Minuten, aber STARTEND bei Minute 2

2/4 * * * * /skript.sh # → 2, 6, 10, 14, ...

Täglich um 3:30 Uhr

30 3 * * * /backup.sh

Montag bis Freitag um 8:00 Uhr

0 8 * * 1-5 /benutzer_check.sh

Jeden 1. des Monats um Mitternacht

0 0 1 * * /monatsabschluss.sh

Stündlich in der Geschäftszeit (9-17 Uhr, Mo-Fr)

0 9-17 * * 1-5 /pruefe_server.sh

Um 6:00 und 18:00 Uhr täglich

0 6,18 * * * /check.sh

Alle 15 Minuten zwischen 8 und 20 Uhr

*/15 8-20 * * * /check.sh

Beim Systemstart

@reboot /home/user/start_dienst.sh

Wöchentlich (Sonntag 0:00 Uhr)

@weekly /backup_woche.sh

Ausgabe in Logdatei umleiten

0 2 * * * /backup.sh >>/var/log/backup.log 2>&1

Ausgabe unterdrücken

0 * * * * /check.sh >/dev/null 2>&1

Mit Benutzerumgebung (PATH explizit setzen)

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

0 3 * * * /eigenes/backup.sh

cron-Umgebungsvariablen

# Am Anfang der crontab-Datei setzbar:

SHELL=/bin/bash

PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin

MAILTO=admin@example.com # Ausgabe per Mail senden (leer = kein Mail)

HOME=/root

Systemweite cron-Verzeichnisse

/etc/crontab # Systemweite crontab (hat Benutzer-Spalte!)

/etc/cron.d/ # Weitere systemweite Cron-Dateien

/etc/cron.hourly/ # Skripte die stündlich laufen

/etc/cron.daily/ # Skripte die täglich laufen

/etc/cron.weekly/ # Skripte die wöchentlich laufen

/etc/cron.monthly/ # Skripte die monatlich laufen

Ausgabe umleiten:

In Datei umleiten

• • • • • echo "test" >/home/user/output.txt 2>&1

An Terminal senden

• • • • • echo "test" >/dev/pts/1

rsync

Grundprinzip

rsync (Remote Sync) ist ein Werkzeug zum effizienten Synchronisieren von Dateien und Verzeichnissen, lokal oder über Netzwerk (SSH). Es überträgt nur geänderte Teile von Dateien (Delta-Transfer-Algorithmus), was es sehr schnell macht.

Grundsyntax:

rsync OPTIONEN QUELLE ZIEL

Wie rsync intern funktioniert (Delta-Algorithmus)

1. Zieldatei wird in Blöcke (Chunks) aufgeteilt
2. Von jedem Block wird eine schwache Prüfsumme (rolling checksum) und eine starke Prüfsumme (MD4/MD5) berechnet
3. Die Prüfsummen werden an den Sender geschickt
4. Der Sender findet passende Blöcke in der Quelldatei
5. Nur neue/geänderte Blöcke werden übertragen
6. Das Ziel wird aus der Kombination alter und neuer Blöcke rekonstruiert

Ergebnis: Statt einer 100 MB Datei werden vielleicht nur 2 KB Unterschied übertragen.

Alle wichtigen Optionen

Der Slash-Trick (sehr wichtig!)

rsync -av /quelle /ziel # Kopiert den Ordner "quelle" IN "ziel" → /ziel/quelle/...

rsync -av /quelle/ /ziel # Kopiert den INHALT von "quelle" → /ziel/...

Der abschließende / an der Quelle macht den Unterschied!

Beispiele

Lokale Synchronisation (einfach)

rsync -av /home/user/daten/ /backup/daten/

# Mit Simulation zuerst überprüfen (-n = dry run)

rsync -avn /home/user/daten/ /backup/daten/

# Remote-Backup über SSH

rsync -avz /home/user/dokumente/ benutzer@server:/backup/dokumente/

# Remote → Lokal (pull)

rsync -avz benutzer@server:/var/www/html/ /lokal/webseite/

# Backup mit --delete (spiegelt exakt)

rsync -av --delete /home/user/ /backup/user/

# SSH-Port 2222 verwenden

rsync -avz -e "ssh -p 2222" /daten/ user@server:/backup/

# SSH-Key angeben

rsync -avz -e "ssh -i ~/.ssh/mein_key" /daten/ user@server:/backup/

# Bestimmte Typen ausschließen

rsync -av --exclude=".tmp" --exclude=".log" /daten/ /backup/daten/

# Ausschlussliste aus Datei (eine Regel pro Zeile)

rsync -av --exclude-from=/home/user/.rsync-exclude /daten/ /backup/

# Nur .jpg Dateien übertragen

rsync -av --include=".jpg" --exclude="" /fotos/ /backup/fotos/

# Bandbreite begrenzen (500 KB/s)

rsync -avz --bwlimit=500 /daten/ user@server:/backup/

# Große Dateien ausschließen

rsync -av --max-size=50M /daten/ /backup/

# Vollständiges Backup mit Versionierung

rsync -av --backup --backup-dir=/backup/$(date %Y-%m-%d) /home/ /backup/aktuell/

# Fortschritt anzeigen

rsync -av --progress /quelle/ /ziel/

# Oder kürzer:

rsync -avP /quelle/ /ziel/

# Übertragungsstatistiken

rsync -av --stats /quelle/ /ziel/

# Dateien nur nach Prüfsumme vergleichen (langsamer aber genauer)

rsync -avc /quelle/ /ziel/

rsync in cron-Jobs

Tägliches Backup um 2:30 Uhr

30 2 * * * rsync -az --delete /home/ /backup/home/ >>/var/log/backup.log 2>&1

Backup mit tar

tar – Archivierung

Archiv erstellen

tar cvf archiv.tar datei1 datei2 verzeichnis/

# Archiv mit Komprimierung (gzip)

tar czf archiv.tar.gz /verzeichnis

# Archiv entpacken

tar xvf archiv.tar

# Komprimiertes Archiv entpacken

tar xzf archiv.tar.gz

# Inhalt anzeigen

tar tf archiv.tar

Optionen:

Backup-Skript (Beispiel):

#!/usr/bin/env bash

set -euo pipefail

BACKUP_SRC=("/etc" "/var/www")

BACKUP_DEST="/backup"

RETENTION_DAYS=7

LOGFILE="/var/log/backup.log"

LOCKFILE="/tmp/backup.lock"

log() {

echo "$(date ' %F %T') $1" | tee -a "$LOGFILE"

}

cleanup() {

rm -f "$LOCKFILE"

}

trap cleanup EXIT

[[ -f "$LOCKFILE" ]] && {

echo "Already running"

exit 1

}

touch "$LOCKFILE"

TIMESTAMP=$(date %F_%H-%M-%S)

TARGET="$BACKUP_DEST/backup_$TIMESTAMP.tar.gz"

log "Starting backup..."

tar -czf "$TARGET" "${BACKUP_SRC[@]}"

log "Cleaning old backups..."

find "$BACKUP_DEST" -type f -mtime $RETENTION_DAYS -name "*.tar.gz" -delete

log "Backup finished."

Bash-Skripting

Skript-Grundlagen & Datenfluss

• Shebang: Beginne ein Skript immer mit #! (z. B. #!/bin/bash), um die Shell festzulegen.
• Ausführbar machen: chmod +x <scriptname>.sh
• Ausgabe überschreiben: > file erstellt oder überschreibt eine Datei.
• Ausgabe anhängen: >> file fügt Text ans Ende einer Datei an.
• Eingabe lesen: < file liest den Inhalt einer Datei ein.
• Pipe: a | b leitet die Ausgabe von Befehl "a" als Eingabe an Befehl "b" weiter.
• Kommentare: # am Beginn der Zeile
• Variablen-Zuweisung: variablenname=”<wert>” (Kein Leerzeichen um das =)
• Variablen-Aufruf: $variablenname (Case-Sensitive)
• Umgebungsvariable: export global=”<wert>”
  • Für Unterprozesse sichtbar
• Script-Aufruf: ./scriptname.sh param1
• User-Eingabe während des Scripts: read -s -r -p “<prompt>” <variablenname>
  • -p “<prompt>”: Prompt vor der Eingabe
  • -s: verdeckte Eingabe (Passwörter)
  • -r: verhindert Escape-Sequenzen

Wichtige Variablen

• $0: Der Name des aufgerufenen Programms.
• $1, $2, …: Das erste und zweite übergebene Argument.
• $#: Die Anzahl der übergebenen Argumente.
• $*: Alle übergebenen Argumente auf einmal.
• $?: Der Rückgabecode des letzten Befehls (0 = Fehlerfrei).
• $$: Die Prozess-ID (PID) des aktuellen Skripts.
• ${V:-default}: Gibt den Wert von $V aus, oder "default", falls die Variable leer ist.

Rechnen mit Variablen

In Bash sind Variablen standardmäßig Text. Wenn mit Zahlen gerechnet werden soll, muss Bash ausdrücklich gesagt werden, dass eine arithmetische Berechnung gemeint ist.

Variable setzen und ausgeben

zahl=5

echo "$zahl"

Wichtig:

zahl=5 # richtig

zahl = 5 # falsch!

Bei Variablenzuweisungen dürfen keine Leerzeichen um das = stehen.

Rechnen mit $(( ... ))

Die empfohlene Schreibweise für Ganzzahlrechnung ist:

a=10

b=3

echo $((a + b)) # 13

echo $((a - b)) # 7

echo $((a * b)) # 30

echo $((a / b)) # 3

echo $((a % b)) # 1

| Operator | Bedeutung | Beispiel |
| --- | --- | --- |
| + | Addition | $((a + b)) |
| - | Subtraktion | $((a - b)) |
|  | Multiplikation | $((a  b)) |
| / | Division | $((a / b)) |
| % | Modulo / Rest | $((a % b)) |

Ergebnis in Variable speichern

a=7

b=4

ergebnis=$((a + b))

echo "Das Ergebnis ist: $ergebnis"

Ausgabe:

Das Ergebnis ist: 11

Variable hochzählen

zahl=1

zahl=$((zahl + 1))

echo "$zahl"

Kurzformen:

((zahl++)) # um 1 erhöhen

((zahl--)) # um 1 verringern

((zahl += 5)) # 5 addieren

((zahl -= 2)) # 2 abziehen

Beispiel:

counter=0

((counter++))

((counter++))

echo "$counter"

Ausgabe:

2

Rechnen in Bedingungen

alter=20

if ((alter >= 18)); then

echo "Volljährig"

else

echo "Minderjährig"

fi

Bei Zahlenvergleichen ist diese Schreibweise oft lesbarer als:

if [ "$alter" -ge 18 ]; then

echo "Volljährig"

fi

Achtung: Bash rechnet nur mit Ganzzahlen

echo $((5 / 2))

Ausgabe:

2

Bash rundet nicht mathematisch, sondern schneidet Nachkommastellen ab. Für Kommazahlen nutzt man z. B. bc:

echo "scale=2; 5 / 2" | bc

Ausgabe:

2.50

Falsch gesetzte Klammern beim Rechnen

Beim Rechnen mit Variablen müssen die Klammern exakt zusammenpassen. Bash unterscheidet zwischen arithmetischer Expansion $(( ... )), normaler Kommando-Ersetzung $( ... ) und Bedingungen mit (( ... )). Eine falsch gesetzte oder vergessene Klammer führt meistens zu einem Syntaxfehler oder zu einem ganz anderen Verhalten.

Richtig: arithmetische Expansion

a=5

b=2

echo $((a + b)) # 7

echo $((a * (b + 3))) # 25

Die äußeren doppelten Klammern $(( ... )) bedeuten: Bash soll den Inhalt als Rechnung auswerten. Innere Klammern können wie in der Mathematik verwendet werden, um die Reihenfolge festzulegen.

Falsch: schließende Klammer fehlt

a=5

b=2

echo $((a + b)

Typische Folge: Bash meldet einen Syntaxfehler, weil die arithmetische Expansion nicht korrekt abgeschlossen wurde, z. B. "unexpected EOF" oder "syntax error".

Falsch: $() statt $(( )) verwendet

a=5

b=2

echo $(a + b)

Das ist keine Rechnung. $( ... ) bedeutet Kommando-Ersetzung. Bash versucht also, den Inhalt als Befehl auszuführen. Dadurch entstehen Fehler wie "command not found".

Falsch: Klammern verändern die Rechenreihenfolge

a=10

b=2

c=3

echo $((a + b * c)) # 16, weil Multiplikation vor Addition gilt

echo $(((a + b) * c)) # 36, weil zuerst a + b gerechnet wird

Klammern sind also nicht nur für die Syntax wichtig, sondern verändern auch das Ergebnis. Wie in der Mathematik wird das berechnet, was in Klammern steht, zuerst.

Falsch: einfache eckige Klammern für Rechnungen erwarten

a=5

b=2

if [ a + b -gt 6 ]; then

echo "größer"

fi

Die einfache eckige Klammer ... ist ein Test-Befehl, aber keine Rechenumgebung. Für Rechnungen in Bedingungen ist (( ... )) besser geeignet:

if ((a + b > 6)); then

echo "größer"

fi

Merksatz zu Klammern beim Rechnen

$(( ... )) = Rechnung ausführen
$( ... ) = Befehl ausführen und Ausgabe einsetzen
(( ... )) = Rechnung/Bedingung auswerten, oft bei if oder Schleifen
... = Test-Befehl, z. B. für Dateien, Strings oder klassische Zahlenvergleiche

Listen, Strings und Arrays

In Bash ist wichtig zu unterscheiden, ob etwas als ein zusammenhängender Text, als mehrere Wörter oder als Array mit mehreren Elementen behandelt wird.

"123" ist ein String

wert="123"

echo "$wert"

Hier ist 123 ein String, also Text. Trotzdem kann Bash damit rechnen, wenn der Inhalt nur aus Zahlen besteht:

wert="123"

echo $((wert + 1))

Ausgabe:

124

Merke:

"123" # ein Text/String mit drei Zeichen

123 # kann in Rechnungen als Zahl verwendet werden

"1 2 3" ist ein String mit Leerzeichen

werte="1 2 3"

echo "$werte"

Ausgabe:

1 2 3

Mit Anführungszeichen bleibt es ein einziger Wert:

for x in "$werte"; do

echo "$x"

done

Ausgabe:

1 2 3

Die Schleife läuft hier nur einmal, weil "$werte" als ein kompletter String behandelt wird.

Ohne Anführungszeichen wird daraus eine Liste

werte="1 2 3"

for x in $werte; do

echo "$x"

done

Ausgabe:

1

2

3

Ohne Anführungszeichen wird der Inhalt an Leerzeichen getrennt. Aus "1 2 3" werden also drei einzelne Werte.

Unterschied: "123" und "1 2 3"

a="123"

b="1 2 3"

for x in $a; do

echo "$x"

done

Ausgabe:

123

123 enthält keine Leerzeichen, also bleibt es ein Wert.

for x in $b; do

echo "$x"

done

Ausgabe:

1

2

3

1 2 3 enthält Leerzeichen, also wird es in mehrere Werte aufgeteilt.

Arrays in Bash

Ein Array ist eine echte Liste mit mehreren Elementen.

zahlen=(1 2 3)

echo "${zahlen[0]}"

echo "${zahlen[1]}"

echo "${zahlen[2]}"

Ausgabe:

1

2

3

Wichtig: Bash-Arrays beginnen bei Index 0.

Alle Array-Elemente ausgeben

zahlen=(1 2 3)

echo "${zahlen[@]}"

Ausgabe:

1 2 3

Über Array iterieren

zahlen=(1 2 3)

for zahl in "${zahlen[@]}"; do

echo "$zahl"

done

Ausgabe:

1

2

3

Diese Schreibweise ist sicher und empfohlen:

"${array@}"

Unterschied zwischen "$array" und "${array@}"

werte=("Apfel Birne" "Banane" "Kirsche")

Richtig:

for wert in "${werte[@]}"; do

echo "$wert"

done

Ausgabe:

Apfel Birne

Banane

Kirsche

Falsch bzw. oft problematisch:

for wert in ${werte[@]}; do

echo "$wert"

done

Ausgabe:

Apfel

Birne

Banane

Kirsche

Ohne Anführungszeichen wird "Apfel Birne" in zwei Wörter zerlegt. Deshalb sollten Arrays fast immer mit "${array@}" durchlaufen werden.

Merksätze

• "123" ist ein String, kann aber als Zahl verwendet werden, wenn nur Ziffern enthalten sind.
• "1 2 3" ist ein String mit Leerzeichen.
• Ohne Anführungszeichen wird an Leerzeichen getrennt.
• Mit Anführungszeichen bleibt der Inhalt ein zusammenhängender Wert.
• Arrays sind echte Listen und werden mit Klammern geschrieben: array=(wert1 wert2 wert3).
• Beim Durchlaufen von Arrays ist "${array@}" die sichere Standardform.

Logik & Bedingungen

Befehle direkt verketten:

• cmd1 && cmd2: Führe cmd1 aus; wenn er erfolgreich war, führe cmd2 aus.
• cmd1 || cmd2: Führe cmd1 aus; wenn er fehlschlägt, führe cmd2 aus.

If-Abfrage:

Bash

if [ "$x" -lt "$y" ]; then

# do something

fi

Die Case-Anweisung (Mehrfach-Auswahl):

Bash

case $foo in

a) echo "foo is A" ;; #(foo = a)

b) echo "foo is B" ;; #(foo = b)

*) echo "foo is not A or B" ;; #(alles anderes)

Esac

(Wichtig: Das ;; am Ende jedes Blocks ist zwingend erforderlich ).

for – loop Beispiel: Über eine Liste iterieren

Dies ist der klassische Anwendungsfall: Du gehst eine Liste von Dateien oder Werten nacheinander durch.

Bash

#!/bin/bash

MEIN_ARRAY=("Apfel Birne" "Banane" "Kirsche")

MEINE_LISTE="Apfel Birne Banane"

for obst in $MEINE_LISTE; do

echo "Ich mag $obst"

done

# Liste von Werten durchgehen

for tier in Hund Katze Maus; do

echo "Das ist ein(e): $tier"

done

Beispiel: Über einen Zahlenbereich iterieren

Wenn du eine Aktion eine bestimmte Anzahl an Malen wiederholen willst (z. B. 5-mal):

Bash

#!/bin/bash

# Zählen von 1 bis 5

for i in {1..5}; do

echo "Durchlauf Nummer: $i"

done

Profi-Tipp: Dateien im Verzeichnis verarbeiten

Ein sehr häufiger Anwendungsfall in der Shell ist es, alle Dateien eines bestimmten Typs zu bearbeiten:

Bash

#!/bin/bash

# Alle .txt Dateien im aktuellen Verzeichnis finden und ausgeben

for datei in *.txt; do

echo "Verarbeite Datei: $datei"

# Hier könnte z.B. ein grep oder cat Befehl folgen

done

Zusammenfassung der Struktur:

• for: Startet die Schleife.
• variable: Ein frei wählbarer Name, der bei jedem Durchlauf den aktuellen Wert annimmt.
• in: Definiert die Liste oder den Bereich, der abgearbeitet wird.
• do: Leitet den Codeblock ein, der für jedes Element ausgeführt wird.
• done: Beendet den Schleifenblock.

for Wenn die Anzahl der Elemente feststeht.

While Wenn du auf einen Zustand wartest.

Continue Wenn ein einzelnes Element ignoriert werden soll.

Break Wenn die Arbeit vorzeitig erledigt ist.

Test-Operatoren (Bedingungen prüfen)

4. Schleifen, Case & Funktionen

While-Schleife (Datei zeilenweise einlesen):

Bash

while read f; do

echo "Line is $f"

done <dateiname.txt

while read benutzer; do

mkdir "/home/$benutzer"

echo "Ordner für $benutzer wurde erstellt."

done <benutzerliste.txt #Datei einlesen wird als 1. Ausgeführt

IF-Abfrage (ausführlich)

Die einfache if-Anweisung

Grundsätzlich hat die if-Anweisung der Bourne-Shell eine sehr einfache Form. Nach dem if steht ein Befehl, der ausgeführt wird. Gibt dieses Kommando eine 0 als Rückgabewert zurück, so gilt die Bedingung als erfüllt und die Aktionen, die zwischen dem folgenden then und fi stehen werden ausgeführt.

if Kommando
then

Aktion
Aktion
...

fi

Natürlich sind die Aktionen auch wieder normale Unix-Befehle. Das „fi“, das den Block beendet, der durch „if … then“ begonnen wurde, ist einfach nur das „if“ rückwärts geschrieben.

Das Programm test

Damit es jetzt sinnvolle Möglichkeiten gibt, Bedingungen zu überprüfen brauchen wir ein Programm, das verschiedene Tests durchführt und jeweils bei gelungenem Test eine 0 als Rückgabewert zurückgibt, bei mislingenem Test eine 1. Dieses Programm heißt test und ermöglicht alle wesentlichen Bedingungsüberprüfungen, die für das Shell-Programmieren notwendig sind.

Damit wir nicht jedesmal schreiben müssen

if test ...

gibt es einen symbolischen Link auf das Programm test, der einfach [ heißt. Allerdings verlangt das Programm test, wenn es merkt, dass es als [ aufgerufen wurde, auch als letzten Parameter eine eckige Klammer zu. Damit ist es also möglich zu schreiben:

if [ ... ]

Wichtig ist hierbei, dass unbedingt ein Leerzeichen zwischen if und der Klammer und zwischen der Klammer und den eigentlichen Tests stehen muß. Es handelt sich bei der Klammer ja tatsächlich um einen Programmaufruf!

DATEI="test.txt" # Prüfen, ob die Datei existiert UND sowohl lesbar als auch beschreibbar ist if [ -f "$DATEI" ] && [ -r "$DATEI" ] && [ -w "$DATEI" ]; then

Die verschiedenen Bedingungsüberprüfungen mit test bzw. [ (Buch Seite 312)

-r Dateiname: if -r file.txt; then: Die Datei Dateiname existiert und ist lesbar

-w Dateiname: Die Datei Dateiname existiert und ist beschreibbar

-x Dateiname: Die Datei Dateiname existiert und ist ausführbar

-d Dateiname: Die Datei Dateiname existiert und ist ein Verzeichnis

-s Dateiname: Die Datei Dateiname existiert und ist nicht leer

-b Dateiname: Die Datei Dateiname existiert und ist ein blockorientiertes Gerät

-c Dateiname: Die Datei Dateiname existiert und ist ein zeichenorientiertes Gerät

-g Dateiname: Die Datei Dateiname existiert und das SGID-Bit ist gesetzt

-k Dateiname: Die Datei Dateiname existiert und das Sticky-Bit ist gesetzt

-u Dateiname: Die Datei Dateiname existiert und das SUID-Bit ist gesetzt

-p Dateiname: Die Datei Dateiname existiert und ist ein Named Pipe

-e Dateiname: Die Datei Dateiname existiert

-f Dateiname: Die Datei Dateiname existiert und ist eine reguläre Datei

-L Dateiname: Die Datei Dateiname existiert und ist ein symbolischer Link

-S Dateiname: Die Datei Dateiname existiert und ist ein Socket

-O Dateiname: Die Datei Dateiname existiert und ist Eigentum des Anwenders, unter dessen UID das test-Programm gerade läuft

-G Dateiname: Die Datei Dateiname existiert und gehört zu der Gruppe, zu der der User gehört, unter dessen UID das test-Programm gerade läuft

Datei1 -nt Datei2: Datei1 ist neuer als Datei2 (newer than)

Datei1 -ot Datei2: Datei1 ist älter als Datei2 (older than)

Datei1 -ef Datei2: Datei1 und Datei2 benutzen die gleiche I-Node (equal file)

-z Zeichenkette: Wahr wenn Zeichenkette eine Länge von Null hat.

-n Zeichenkette: Wahr wenn Zeichenkette eine Länge von größer als Null hat.

Zeichenkette1 = Zeichenkette2: Wahr wenn Zeichenkette1 gleich Zeichenkette2

Zeichenkette1 != Zeichenkette2: Wahr wenn Zeichenkette1 ungleich Zeichenkette2

Wert1 -eq Wert2: Wahr, wenn Wert1 gleich Wert2 (equal)

Wert1 -ne Wert2: Wahr, wenn Wert1 ungleich Wert2 (not equal)

Wert1 -gt Wert2: Wahr, wenn Wert1 größer Wert2 (greater than)

Wert1 -ge Wert2: Wahr, wenn Wert1 größer oder gleich Wert2 (greater or equal)

Wert1 -lt Wert2: Wahr, wenn Wert1 kleiner Wert2 (less than)

Wert1 -le Wert2: Wahr, wenn Wert1 kleiner oder gleich Wert2 (less or equal)

!Ausdruck: Logische Verneinung von Ausdruck

Ausdruck -a Ausdruck: Logisches UND. Wahr, wenn beide Ausdrücke wahr sind

Ausdruck -o Ausdruck: Logisches ODER. Wahr wenn mindestens einer der beiden Ausdrücke wahr ist

Mit diesen Tests sind so ziemlich alle denkbaren Bedingungsüberprüfungen möglich, die in einem Shellscript notwendig sind.

Die erweiterte if-else Anweisung

Natürlich bietet die if-Anweisung auch eine Erweiterung zur normalen Form, die sogenannte if-else Anweisung. Es ist also möglich zu schreiben:

if [ Ausdruck ];
then
Kommandos
else
Kommandos
fi

Die if-elif-else Anweisung

Um noch einen Schritt weiterzugehen bietet die if-Anweisung sogar ein weiteres if im else, das sogenannte elif, das wieder eine Bedingung überprüft:

if [ Ausdruck ];
then
Kommandos
elif [ Ausdruck ];
then
Kommandos
else
Kommandos
fi

Mehrfachauswahl mit case

Oft kommt es vor, dass eine Variable ausgewertet werden muß und es dabei viele verschiedenen Möglichkeiten gibt, welche Werte diese Variable annehmen kann. Natürlich wäre es mit einer langen if-elif-elif-elif… Anweisung möglich, so etwas zu realisieren, das wäre aber sowohl umständlich, als auch schwer zu lesen. Damit solche Fälle einfacher realisiert werden können, gibt es die Mehrfachauswahl mit case. Der prinzipielle Aufbau einer case-Entscheidung sieht folgendermaßen aus:

case Variable in
Muster1) Kommando1 ;;
Muster2) Kommando2 ;;
Muster3) Kommando3 ;;

...

esac

Essenzielle Werkzeuge

• Suchen: grep foo myfile findet Zeilen mit dem Text "foo" in einer Datei.
• Dateien finden: find . -name "*.txt" -print sucht nach Textdateien im aktuellen Verzeichnis.
• Text filtern: awk '{print $5}' file gibt nur das 5. Wort jeder Zeile aus.
• Text ersetzen: sed s/foo/bar/g file ersetzt "foo" durch "bar".

Funktionen

Definition

meine_funktion() {

echo "Hallo $1!"

}

# Aufruf

meine_funktion "Welt"

# Mit Rückgabewert (Exit-Code 0-255)

ist_gerade() {

if (($1 % 2 == 0)); then

return 0

else

return 1

fi

}

# Werte "zurückgeben" über echo

berechne() {

echo $(($1 * $1))

}

ergebnis=$(berechne 5)

# Lokale Variablen

funktion() {

local zahl=5 # Nur innerhalb der Funktion sichtbar

echo $zahl

}

Best Practices

Fehlerbehandlung mit trap

cleanup() {

rm -f "$LOCKFILE"

echo "Aufgeräumt"

}

trap cleanup EXIT INT TERM

Locking (verhindert doppelte Ausführung)

LOCKFILE="/tmp/myscript.lock"

exec 200>"$LOCKFILE"

flock -n 200 || {

echo "Already running"

exit 1

}

main()-Struktur (empfohlen)

#!/bin/bash

set -euo pipefail

check_input() {

if [ -z "$1" ]; then

echo "Kein Parameter!"

exit 1

fi

}

verarbeite() {

echo "Verarbeite: $1"

}

main() {

check_input "$1"

verarbeite "$1"

}

main "$@"

VM vs. Docker

Virtualisierung

Begriffe (Virtualisierung):

• Hostsystem = System, auf dem die Virtualisierung läuft
• Gastsystem = System in der VM
• Hypervisor / VMM = Virtualisierungssoftware

VirtualBox Netzwerktypen:

Docker

Grundbegriffe

Wichtige Docker-Befehle

Images verwalten

docker image pull nginx # Image herunterladen

docker image build -t myapp:1.0 . # Image aus Dockerfile bauen

docker image ls # Alle Images anzeigen

docker image rm nginx # Image löschen

docker images prune # Ungenutzte Images löschen

Container verwalten

Container erstellen und starten

docker run -d -p 8080:80 --name myweb nginx

docker run -it ubuntu bash # Interaktiv starten

docker run --rm alpine echo "Hello" # Nach Beenden löschen

# Container verwalten

docker container ls # Laufende Container

docker container ls -a # Alle Container

docker container stop myweb # Stoppen

docker container start myweb # Starten

docker container rm myweb # Löschen

docker container rm -f myweb # Erzwungen löschen

docker container inspect myweb # Details anzeigen

# Im Container arbeiten

docker exec -it myweb bash # Shell in laufendem Container

docker logs myweb # Logs anzeigen

docker logs -f myweb # Live-Logs

docker stats # Ressourcen-Monitoring

docker run Optionen

Volumes

docker volume create myvolume # Volume erstellen

docker volume ls # Alle Volumes

docker volume inspect myvolume # Details

docker volume rm myvolume # Löschen

# Mit Volume starten

docker run -v myvolume:/data ubuntu

# Bind Mount (lokales Verzeichnis)

docker run -v /home/user/html:/usr/share/nginx/html nginx

Netzwerke

docker network create mynetwork # Netzwerk erstellen

docker network rm mynetwork # Netzwerk löschen

# Container im gleichen Netzwerk können sich über Namen erreichen:

docker run -d --network mynetwork --name db mongo

docker run -d --network mynetwork --name app node-app

# → app kann db über "db" als Hostname ansprechen

Dockerfile – Image erstellen

# Basis-Image

FROM python:3.10-slim

# Arbeitsverzeichnis setzen

WORKDIR /app

# Abhängigkeiten zuerst kopieren (Layer-Cache!)

COPY requirements.txt .

RUN pip install -r requirements.txt

# Quellcode kopieren

COPY . .

# Benutzer erstellen (Sicherheit!)

RUN addgroup app && adduser -S -G app app

USER app

# Port dokumentieren

EXPOSE 5000

# Umgebungsvariable

ENV APP_ENV=production

# Startbefehl (Exec-Format bevorzugt!)

CMD ["python", "app.py"]

Wichtige Dockerfile-Anweisungen:

Multi-Stage Build (Image-Optimierung):

# Stage 1: Build

FROM node:14 AS build

WORKDIR /app

COPY . .

RUN npm install && npm run build

# Stage 2: Production (nur fertiges Ergebnis!)

FROM nginx:alpine

COPY --from=build /app/build /usr/share/nginx/html

Layer-Cache-Optimierung:

• Stabile Dateien (package.json) vor veränderlichen Dateien (Quellcode) kopieren
• So werden Abhängigkeiten nur bei Änderung neu installiert

Container-Lebenszyklus:

Erstellt → docker run → Running → docker stop → Stopped
→ docker kill → Gelöscht
Running → docker pause → Paused → docker unpause → Running

Docker Compose

Grundprinzip

docker compose (früher: docker-compose) ermöglicht die Definition und Verwaltung mehrerer zusammengehöriger Container (Multi-Container-Anwendungen) über eine einzige YAML-Konfigurationsdatei.

docker compose [OPTIONEN] BEFEHL

Konfigurationsdatei: docker-compose.yml (oder docker-compose.yaml)

Alle docker compose Befehle

Optionen für docker compose up

Optionen für docker compose down