Linux – Grundbefehle für IT-Allrounder

Warum du als IT-Allrounder Linux brauchst

Auch wenn dein Arbeitsalltag hauptsächlich aus Windows besteht: Linux begegnet dir früher oder später. Webserver, NAS-Systeme, Firewalls, Docker-Container, Raspberry Pi, virtuelle Maschinen – ein riesiger Teil der IT-Infrastruktur läuft auf Linux. Wer die Kommandozeile nicht scheut, kann Probleme direkt am Server lösen, ohne eine GUI zu brauchen.

Diese Seite gibt dir einen praxisnahen Einstieg in die wichtigsten Befehle und führt danach in fortgeschrittene Werkzeuge ein, die im Alltag eines Admins ständig gebraucht werden: eigene Bash-Skripte, sed/awk zur Textverarbeitung, ACLs für feingranulare Berechtigungen, tmux für Sessions, die einen Verbindungsabbruch überleben, und rsync für effiziente Synchronisation. Du brauchst kein Vorwissen für den Einstieg – nur ein Terminal und etwas Neugier.

Terminal öffnen

Das Terminal ist dein Werkzeug. Auf den meisten Desktop-Distributionen öffnest du es mit Strg+Alt+T. Auf einem Server ohne GUI ist das Terminal automatisch das, was dich begrüsst – meistens über SSH.

Das Prompt sieht typischerweise so aus:

seya@server01:~$

• seya = eingeloggter Benutzer
• server01 = Hostname
• ~ = aktuelles Verzeichnis (hier: Home-Verzeichnis)
• $ = normaler Benutzer (bei Root wäre es #)

Navigation im Dateisystem

Das Linux-Dateisystem ist eine Baumstruktur. Alles beginnt bei / (Root). Kein Laufwerksbuchstabe wie in Windows – stattdessen gibt es feste Verzeichnisse wie /etc (Konfiguration), /var/log (Logs), /home (Benutzerordner), /tmp (temporäre Dateien).

pwd                         # Zeigt, wo du gerade bist ("Print Working Directory")
ls                          # Inhalt des aktuellen Verzeichnisses auflisten
ls -l                       # Detailansicht: Berechtigungen, Grösse, Datum
ls -la                      # Wie -l, aber auch versteckte Dateien (beginnen mit Punkt)
ls -lh                      # Wie -l, aber Dateigrössen menschenlesbar (KB, MB)

cd /etc                     # In das Verzeichnis /etc wechseln
cd ~                        # Ins eigene Home-Verzeichnis springen
cd ..                       # Eine Ebene höher
cd -                        # Zurück ins letzte Verzeichnis (praktisch!)

Beispiel: Logdateien auf einem Server aufspüren

cd /var/log
ls -lh
# -> zeigt alle Logs mit Grösse und Datum

Wichtige Verzeichnisse auf einen Blick

Dateien und Verzeichnisse verwalten

mkdir logs                      # Verzeichnis "logs" erstellen
mkdir -p /opt/app/logs          # Verzeichnis inklusive aller Elternordner erstellen

touch datei.txt                 # Leere Datei erstellen (oder Timestamp aktualisieren)

cp datei.txt backup.txt         # Datei kopieren
cp -r /etc/nginx /tmp/nginx-bak # Verzeichnis rekursiv kopieren

mv alte.txt neue.txt            # Datei umbenennen
mv datei.txt /tmp/              # Datei in ein anderes Verzeichnis verschieben

rm datei.txt                    # Datei löschen
rm -rf /tmp/test                # Verzeichnis rekursiv und ohne Rückfrage löschen

ln -s /opt/app/config /etc/app  # Symbolischen Link erstellen

Dateien suchen

find /var/log -name "*.log"             # Alle .log-Dateien unter /var/log suchen
find /home -name "*.txt" -mtime -7      # .txt-Dateien, geändert in den letzten 7 Tagen
find / -name "nginx.conf" 2>/dev/null   # Überall suchen, Fehler unterdrücken

which nginx                             # Pfad zu einem Programm anzeigen
locate nginx.conf                       # Schnelle Dateisuche (aus Index, muss aktuell sein)

Dateien synchronisieren mit rsync

cp -r reicht für einmalige Kopien. Sobald du regelmässig grosse Verzeichnisse abgleichen musst – Backups, Deployments, Migrationen zwischen Servern – ist rsync das richtige Werkzeug. Es überträgt standardmässig nur die Unterschiede zwischen Quelle und Ziel (delta-basiert), nicht die kompletten Dateien erneut.

rsync -avh /var/www/ /backup/www/               # Lokal synchronisieren
# -a = archive (Rechte, Zeitstempel, Symlinks, rekursiv erhalten)
# -v = verbose (zeigt übertragene Dateien)
# -h = human-readable (Grössenangaben lesbar)

rsync -avh --dry-run /var/www/ /backup/www/     # Testlauf ohne echte Übertragung
rsync -avh --delete /var/www/ /backup/www/      # Ziel exakt spiegeln (löscht Dateien, die in der Quelle fehlen)

# Über SSH auf einen entfernten Server synchronisieren
rsync -avz -e ssh /var/www/ seya@server02:/var/www/
# -z = Daten komprimiert übertragen (spart Bandbreite)

rsync -avh --exclude='*.tmp' --exclude='cache/' /app/ /backup/app/

Dateiinhalte lesen und durchsuchen

cat datei.txt                   # Kompletten Inhalt ausgeben
less datei.txt                  # Seitenweise blättern (q zum Beenden, / zum Suchen)
head -n 20 datei.txt            # Erste 20 Zeilen
tail -n 50 datei.txt            # Letzte 50 Zeilen
tail -f /var/log/syslog         # Live-Ausgabe: neue Zeilen werden sofort angezeigt

grep – der mächtigste Suchbefehl

grep "error" /var/log/syslog            # Zeilen mit "error" ausgeben
grep -i "ERROR" /var/log/syslog         # Gross-/Kleinschreibung ignorieren
grep -r "timeout" /etc/nginx/           # Rekursiv in einem Verzeichnis suchen
grep -n "fail" /var/log/auth.log        # Mit Zeilennummern
grep -v "DEBUG" /var/log/app.log        # Zeilen OHNE "DEBUG" anzeigen
grep -c "error" /var/log/syslog         # Nur Anzahl der Treffer ausgeben

# Kombinieren mit Pipe (|)
tail -f /var/log/syslog | grep "error"  # Nur Fehler im Live-Log anzeigen
cat access.log | grep "192.168.1.10"    # Alle Einträge einer bestimmten IP

Erweiterte grep-Nutzung: -E, -P und find -exec

Für komplexere Muster reicht einfaches grep nicht mehr. Mit -E (extended regex) musst du Klammern und Quantifizierer nicht mehr escapen, mit -P (Perl-kompatible Regex, PCRE) stehen dir sogar Lookaheads zur Verfügung.

# -E: mehrere Muster gleichzeitig, Gruppen ohne Backslash
grep -E "error|warning|critical" app.log
grep -E "^(200|301|302) " access.log        # Nur bestimmte HTTP-Statuscodes am Zeilenanfang

# -P: Perl-kompatible Regex mit Lookahead (nur GNU grep, nicht auf macOS/BSD)
grep -P '(?<=user=)\w+' auth.log            # Extrahiert nur den Wert nach "user="
grep -P 'fehler(?!behoben)' app.log         # "fehler", aber NICHT gefolgt von "behoben"

# Nur die Treffer selbst ausgeben, nicht die ganze Zeile
grep -oP '(?<=ip=)[\d.]+' access.log        # Nur die IP-Adresse nach "ip=" extrahieren

find -exec kombiniert Suche und Aktion in einem Schritt – nützlich für Aufräumjobs:

find /var/log -name "*.log" -mtime +30 -exec rm {} \;      # Logs älter als 30 Tage löschen
find /var/log -name "*.log" -mtime +30 -exec rm {} +       # Effizienter: ein rm-Aufruf für alle Treffer
find /tmp -type f -size +100M -exec ls -lh {} \;           # Grosse Dateien in /tmp auflisten
find . -name "*.sh" -exec chmod +x {} \;                   # Alle Skripte im aktuellen Ordner ausführbar machen

Textverarbeitung mit sed und awk

grep findet Zeilen – sed und awk verändern und verarbeiten sie. Beide sind für Skripte und Log-Auswertung unverzichtbar.

sed – Stream-Editor für Suchen/Ersetzen

sed 's/http/https/' config.txt              # Erstes Vorkommen pro Zeile ersetzen (Ausgabe auf Bildschirm)
sed 's/http/https/g' config.txt             # Alle Vorkommen pro Zeile ersetzen (global)
sed -i 's/http/https/g' config.txt          # Direkt in der Datei ändern (in-place, ohne Backup)
sed -i.bak 's/http/https/g' config.txt      # In-place ändern, aber Backup als config.txt.bak behalten

sed -n '10,20p' datei.txt                   # Nur Zeilen 10 bis 20 ausgeben
sed '/^#/d' config.txt                      # Alle Kommentarzeilen (beginnen mit #) entfernen
sed '5d' datei.txt                          # Zeile 5 löschen

awk – Spaltenbasierte Textverarbeitung

awk zerlegt jede Zeile automatisch in Felder (Standard: Leerzeichen/Tabs) und macht Auswertungen pro Spalte einfach.

awk '{print $1}' access.log                 # Nur die erste Spalte ausgeben (z.B. IP-Adresse)
awk '{print $1, $NF}' access.log            # Erste und letzte Spalte ausgeben
awk -F':' '{print $1}' /etc/passwd          # Feldtrenner ":" setzen, nur Benutzernamen ausgeben
awk '/error/ {print $0}' app.log            # Nur Zeilen mit "error" ausgeben (wie grep, aber mächtiger)
awk '{sum += $NF} END {print sum}' traffic.log   # Letzte Spalte aller Zeilen aufsummieren
awk '$3 > 1000 {print $1}' report.txt       # Nur Zeilen ausgeben, bei denen Spalte 3 grösser als 1000 ist

Praxisbeispiel: Top-IPs aus einem Access-Log

awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -10
# awk extrahiert die IP (Spalte 1), sort+uniq -c zählt Vorkommen, sort -rn sortiert absteigend

Benutzer, Gruppen und Berechtigungen

Wer bin ich?

whoami                  # Aktuellen Benutzernamen anzeigen
id                      # UID, GID und alle Gruppen des aktuellen Benutzers
id seya                 # Infos zu einem anderen Benutzer
groups                  # Nur die eigenen Gruppen

sudo – als Root handeln

sudo apt update                 # Befehl als Root ausführen
sudo -i                         # Root-Shell öffnen (Vorsicht!)
sudo -u www-data bash           # Shell als anderer Benutzer öffnen
su - seya                       # Zu anderem Benutzer wechseln (braucht dessen Passwort)

Benutzer verwalten

useradd -m -s /bin/bash seya    # Benutzer erstellen (mit Home-Verzeichnis und Bash)
passwd seya                     # Passwort setzen oder ändern
usermod -aG sudo seya           # Benutzer zur sudo-Gruppe hinzufügen
usermod -aG docker seya         # Benutzer zur docker-Gruppe hinzufügen
userdel -r seya                 # Benutzer löschen (inkl. Home-Verzeichnis)

cat /etc/passwd                 # Alle Benutzer auflisten
getent group sudo               # Mitglieder einer Gruppe anzeigen

Dateiberechtigungen lesen und setzen

Linux-Berechtigungen bestehen aus drei Teilen: Owner (Besitzer), Group (Gruppe), Others (alle anderen). Jeder Teil hat Read (r=4), Write (w=2), Execute (x=1).

ls -l datei.sh
# -> -rwxr-xr-- 1 seya staff 1234 Jun 23 10:00 datei.sh
#    rwx        = Owner kann lesen, schreiben, ausführen
#    r-x        = Gruppe kann lesen und ausführen
#    r--        = Andere können nur lesen

chmod 755 skript.sh             # rwxr-xr-x (Owner alles, Rest nur lesen/ausführen)
chmod 644 config.txt            # rw-r--r-- (Owner schreiben, Rest nur lesen)
chmod +x skript.sh              # Ausführbar machen (für alle)
chmod -x skript.sh              # Ausführbar-Flag entfernen

chown seya datei.txt            # Besitzer ändern
chown seya:staff datei.txt      # Besitzer und Gruppe ändern
chown -R www-data /var/www      # Rekursiv Besitzer für ganzes Verzeichnis setzen

ACLs und erweiterte Attribute: mehr Kontrolle als chmod

Klassische Unix-Rechte (Owner/Gruppe/Andere) stossen an Grenzen, sobald mehrere Benutzer oder Gruppen unterschiedliche Rechte auf dieselbe Datei brauchen sollen. Genau dafür gibt es ACLs (Access Control Lists).

getfacl datei.txt                       # Aktuelle ACL einer Datei anzeigen

setfacl -m u:lisa:rwx datei.txt         # Benutzer "lisa" zusätzlich Vollzugriff geben
setfacl -m g:support:rx datei.txt       # Gruppe "support" Lese-/Ausführrecht geben
setfacl -m u:lisa:--- datei.txt         # Zugriff für "lisa" explizit entziehen (ohne sie zu entfernen)
setfacl -x u:lisa datei.txt             # ACL-Eintrag für "lisa" wieder entfernen
setfacl -b datei.txt                    # Alle ACL-Einträge entfernen, zurück zu reinem chmod

setfacl -R -m u:lisa:rwx /freigabe/     # Rekursiv auf ein ganzes Verzeichnis anwenden
setfacl -d -m u:lisa:rwx /freigabe/     # Default-ACL: gilt automatisch für alle NEUEN Dateien im Ordner

Praxisbeispiel: Ein gemeinsamer Projektordner /freigabe/projekt-x, in dem die Gruppe projekt-x Schreibrechte hat, aber zusätzlich der externe Berater lisa (nicht Mitglied der Gruppe) nur lesen darf:

chown -R :projekt-x /freigabe/projekt-x
chmod -R 770 /freigabe/projekt-x
setfacl -R -m u:lisa:r-x /freigabe/projekt-x
setfacl -d -m u:lisa:r-x /freigabe/projekt-x

chattr – Attribute unterhalb der Dateiberechtigungen

chattr setzt Dateisystem-Attribute, die sogar Root-Rechte einschränken – nützlich, um kritische Dateien vor versehentlichem Überschreiben zu schützen.

chattr +i /etc/resolv.conf      # Datei "immutable" (unveränderlich) machen – auch root kann sie nicht löschen/ändern
lsattr /etc/resolv.conf         # Attribute einer Datei anzeigen
chattr -i /etc/resolv.conf      # Immutable-Flag wieder entfernen

chattr +a /var/log/audit.log    # "Append only" – Datei darf nur erweitert, nicht überschrieben/gelöscht werden

Prozesse und Systemübersicht

ps aux                          # Alle laufenden Prozesse aller Benutzer
ps aux | grep nginx             # Prozesse nach Name filtern
top                             # Live-Prozessübersicht (q zum Beenden)
htop                            # Verbesserte top-Version (muss installiert werden)

kill 1234                       # Prozess mit PID 1234 beenden (freundlich)
kill -9 1234                    # Prozess erzwungen beenden (SIGKILL)
pkill nginx                     # Prozess nach Name beenden
killall -9 python3              # Alle Instanzen eines Programms beenden

Systemressourcen im Blick

df -h                           # Festplattennutzung (menschenlesbar)
df -h /var                      # Nur ein bestimmtes Dateisystem
du -sh /var/log                 # Grösse eines Verzeichnisses
du -sh /var/log/*               # Grösse aller Unterordner

free -h                         # RAM-Nutzung (total, used, free, cached)
uptime                          # Systemlaufzeit und CPU-Last (1/5/15 Min)
uname -a                        # Kernel-Version und Architektur
lscpu                           # CPU-Informationen
lsblk                           # Blockgeräte (Festplatten, Partitionen)

Typischer Troubleshooting-Ablauf: Disk Full

df -h                           # Welche Partition ist voll?
du -sh /var/log/*               # Was belegt am meisten Platz?
ls -lhS /var/log/               # Grösste Dateien zuerst anzeigen
# -> Verdächtige Logdatei gefunden: 8 GB nginx-access.log
truncate -s 0 /var/log/nginx/access.log   # Datei leeren (nicht löschen!)

Netzwerkbefehle

ip a                            # Alle Netzwerkinterfaces mit IP-Adressen
ip r                            # Routing-Tabelle
ip link show                    # Interface-Status (up/down)

ss -tulpn                       # Alle offenen Ports und zugehörige Prozesse
ss -tulpn | grep :80            # Wer hört auf Port 80?

ping -c 4 8.8.8.8               # 4 Pings an Google DNS (Erreichbarkeit testen)
traceroute 8.8.8.8              # Netzwerkpfad zum Ziel verfolgen
nslookup firma.ch               # DNS-Auflösung testen
dig firma.ch                    # Detaillierte DNS-Abfrage
host 192.168.1.1                # Reverse-DNS-Lookup

curl -I https://firma.ch        # HTTP-Header einer URL abrufen
curl -s https://api.example.com/status  # API-Endpunkt testen
wget https://example.com/datei.zip      # Datei herunterladen

Offene Ports prüfen – wer lauscht wo?

ss -tulpn
# -> Zeigt: Proto, Local Address:Port, Process
# Beispiel-Output:
# tcp  LISTEN  0  128  0.0.0.0:22    users:(("sshd",pid=1234))
# tcp  LISTEN  0  128  0.0.0.0:80    users:(("nginx",pid=5678))

Paketverwaltung

Debian / Ubuntu (apt)

apt update                          # Paketlisten aktualisieren (kein Upgrade!)
apt upgrade -y                      # Alle installierten Pakete aktualisieren
apt install htop curl vim -y        # Pakete installieren
apt remove paketname                # Paket entfernen
apt autoremove                      # Nicht mehr benötigte Pakete aufräumen
apt search stichwort                # Nach Paket suchen
apt show nginx                      # Details zu einem Paket
dpkg -l | grep nginx                # Prüfen ob ein Paket installiert ist

RHEL / Rocky / AlmaLinux (dnf)

dnf update -y                       # System aktualisieren
dnf install htop curl vim -y        # Pakete installieren
dnf remove paketname                # Paket entfernen
dnf search stichwort                # Nach Paket suchen
rpm -qa | grep nginx                # Installierte Pakete filtern

Pipes, Umleitungen und praktische Shortcuts

Diese Konzepte machen die Shell so mächtig:

# Pipe: Output eines Befehls als Input des nächsten
ps aux | grep nginx
cat /var/log/syslog | grep error | tail -n 20

# Ausgabe in Datei umleiten
echo "Backup erfolgreich" > backup.log      # Datei überschreiben
echo "Weiterer Eintrag" >> backup.log       # Datei anhängen
ls -la /etc > /tmp/etc-listing.txt

# Fehlerausgabe
befehl 2>/dev/null                          # Fehlermeldungen unterdrücken
befehl > ausgabe.log 2>&1                   # Alles (stdout + stderr) in Datei

# Mehrere Befehle verketten
apt update && apt upgrade -y                # Zweiter Befehl nur wenn erster erfolgreich
rm /tmp/test || echo "Löschen fehlgeschlagen"  # Zweiter Befehl wenn erster scheitert

Weitere nützliche Shortcuts im Terminal:

Bash-Scripting-Basics: Vom Einzelbefehl zum Skript

Sobald du dieselbe Befehlsfolge öfter als zweimal brauchst, lohnt sich ein Skript. Ein Bash-Skript ist nichts anderes als eine Textdatei mit Befehlen, die nacheinander ausgeführt werden – plus ein paar Programmierkonzepte, die das Ganze robust machen.

Shebang und Grundgerüst

Jedes Skript beginnt mit einer Shebang-Zeile, die dem System sagt, welcher Interpreter es ausführen soll:

#!/bin/bash
echo "Skript gestartet"

chmod +x skript.sh              # Skript ausführbar machen
./skript.sh                     # Ausführen (Pfad nötig, sonst wird $PATH durchsucht)
bash skript.sh                  # Alternative: Interpreter direkt aufrufen (Ausführrecht nicht nötig)

Variablen

NAME="server01"
ANZAHL=5

echo "Host: $NAME"              # Variable auslesen
echo "Host: ${NAME}"            # Gleich, aber eindeutig abgegrenzt (wichtig bei ${NAME}_backup)
ERGEBNIS=$(hostname)            # Command Substitution: Ausgabe eines Befehls in Variable speichern

Bedingungen mit if

STATUS="active"

if [ "$STATUS" = "active" ]; then
  echo "Dienst läuft"
elif [ "$STATUS" = "failed" ]; then
  echo "Dienst ist fehlgeschlagen"
else
  echo "Status unbekannt"
fi

# Häufige Test-Operatoren:
# -f DATEI    Datei existiert
# -d ORDNER   Verzeichnis existiert
# -z "$VAR"   Variable ist leer
# -eq -ne -gt -lt   Vergleich von Zahlen
# =  !=       Vergleich von Zeichenketten

if [ -f /etc/nginx/nginx.conf ]; then
  echo "Konfiguration gefunden"
fi

Schleifen: for und while

for i in 1 2 3; do
  echo "Durchlauf $i"
done

for datei in /var/log/*.log; do
  echo "Verarbeite: $datei"
done

while read -r zeile; do
  echo "Zeile: $zeile"
done < server-liste.txt

Funktionen

backup_datei() {
  local quelle="$1"
  local ziel="$2"
  cp "$quelle" "$ziel"
  echo "Backup von $quelle nach $ziel erstellt"
}

backup_datei /etc/nginx/nginx.conf /tmp/nginx.conf.bak

Exit-Codes

Jeder Befehl liefert nach Beendigung einen Exit-Code zurück: 0 bedeutet Erfolg, jeder andere Wert (1–255) einen Fehler. Der letzte Exit-Code steht in der Spezialvariable $?.

ls /existiert-nicht
echo $?                         # -> 2 (Fehler: Datei nicht gefunden)

ls /etc
echo $?                         # -> 0 (Erfolg)

In eigenen Skripten steuerst du das mit exit:

#!/bin/bash
if [ ! -f /etc/nginx/nginx.conf ]; then
  echo "Fehler: Konfiguration fehlt"
  exit 1
fi
echo "Alles ok"
exit 0

Vollständiges Beispiel: Ein Disk-Space-Check als Skript

#!/bin/bash
# check-diskspace.sh – Warnt, wenn eine Partition zu voll wird

SCHWELLENWERT=90
PARTITION="/"

BELEGT=$(df --output=pcent "$PARTITION" | tail -n 1 | tr -d ' %')

if [ "$BELEGT" -ge "$SCHWELLENWERT" ]; then
  echo "WARNUNG: $PARTITION ist zu $BELEGT% voll!"
  exit 1
else
  echo "OK: $PARTITION ist zu $BELEGT% belegt."
  exit 0
fi

chmod +x check-diskspace.sh
./check-diskspace.sh
echo $?                         # Exit-Code des Skripts prüfen – ideal für Monitoring oder cron

Solche Skripte lassen sich direkt mit Cron Jobs automatisieren, zum Beispiel um sie jede Stunde laufen zu lassen und bei Exit-Code 1 eine Warnung auszulösen.

Häufige Troubleshooting-Situationen

Dienst startet nicht

systemctl status nginx          # Status und letzte Logzeilen anzeigen
journalctl -u nginx -n 50       # Letzte 50 Log-Einträge des Dienstes
journalctl -u nginx -f          # Live mitlesen
nginx -t                        # Konfiguration auf Syntaxfehler prüfen

Mehr zur Dienstverwaltung findest du unter Linux systemd.

Verbindung schlägt fehl

ping 192.168.1.10               # Host erreichbar?
ss -tulpn | grep :80            # Lauscht der Dienst überhaupt?
curl -v http://192.168.1.10     # HTTP-Verbindung testen mit Details
# Firewall prüfen:
iptables -L -n                  # Regeln anzeigen (ältere Systeme)
ufw status                      # UFW-Firewall-Status (Ubuntu)
firewall-cmd --list-all         # firewalld-Status (RHEL/Rocky)

Detaillierte Firewall-Konfiguration mit iptables/nftables steht unter Linux Firewall (iptables/nftables).

Welcher Prozess blockiert eine Datei oder einen Port?

lsof /var/log/nginx/error.log   # Welcher Prozess hat diese Datei geöffnet?
lsof -i :80                     # Welcher Prozess nutzt Port 80?
fuser 80/tcp                    # PID des Prozesses auf Port 80

Zu wenig Festplattenplatz

df -h                                   # Übersicht aller Partitionen
du -sh /var/log/* | sort -rh | head -10 # Top 10 der grössten Log-Verzeichnisse
find /var/log -name "*.log" -size +100M # Logs grösser als 100 MB finden
journalctl --disk-usage                 # Wie viel Platz belegen die journald-Logs?
journalctl --vacuum-size=500M           # journald-Logs auf 500 MB begrenzen

Textdateien bearbeiten

Auf einem Server ohne GUI brauchst du einen Terminal-Editor. Die zwei wichtigsten:

nano – einfach, anfängerfreundlich:

nano /etc/hosts                 # Datei bearbeiten
# Strg+O = Speichern, Strg+X = Beenden, Strg+W = Suchen

vim – mächtig, aber mit Lernkurve:

vim /etc/nginx/nginx.conf
# i = Insert-Modus (schreiben)
# Esc = Normal-Modus
# :w = Speichern
# :q = Beenden
# :wq = Speichern und Beenden
# :q! = Beenden ohne Speichern
# /suchbegriff = Suchen, n = nächster Treffer

tmux und screen: Sessions, die einen Verbindungsabbruch überleben

Ein häufiges Problem bei Arbeiten über SSH: Ein langlaufender Befehl (Updates, ein grosses rsync, ein Build) läuft im Terminal – und die Verbindung bricht ab. Ohne Vorkehrung stirbt der Prozess mit der Session. tmux (Terminal Multiplexer) und das ältere screen lösen das: Sie lassen Sitzungen im Hintergrund weiterlaufen, auch wenn die SSH-Verbindung getrennt wird, und man kann sich später wieder “andocken”.

tmux – der heutige Standard

tmux new -s wartung             # Neue benannte Session starten
tmux ls                         # Laufende Sessions auflisten
tmux attach -t wartung          # Wieder an eine Session andocken
tmux kill-session -t wartung    # Session beenden

Innerhalb von tmux beginnt jede Tastenkombination mit dem Prefix Strg+B, gefolgt von einer weiteren Taste:

Praxisbeispiel: Ein grosses rsync-Backup starten, das die Nacht über läuft, ohne dass die SSH-Verbindung offen bleiben muss:

tmux new -s backup
rsync -avh --delete /data/ backup-server:/backup/data/
# Strg+B dann D drücken -> Verbindung trennen, Befehl läuft weiter
# Am nächsten Tag:
tmux attach -t backup

screen – die ältere Alternative

Auf vielen älteren oder minimalen Systemen ist nur screen vorinstalliert:

screen -S wartung               # Neue benannte Session starten
screen -ls                      # Laufende Sessions auflisten
screen -r wartung               # Wieder andocken
# Detach: Strg+A dann D

Crosslinks

Hast du die Grundbefehle im Griff, sind das die logischen nächsten Schritte:

• SSH – Grundlagen und Schlüsselverwaltung – Remote-Zugriff auf Linux-Server
• Cron Jobs – Automatisierung unter Linux – Aufgaben zeitgesteuert ausführen, z.B. eigene Bash-Skripte
• Linux systemd – Dienste verwalten – Services starten, stoppen, überwachen
• Linux Firewall (iptables/nftables) – Netzwerkzugriff auf Linux-Servern kontrollieren
• Linux Hardening & Security – Server systematisch absichern, u.a. mit ACLs und Attributen
• Docker – Container Grundlagen – Applikationen in Containern betreiben
• PowerShell IT-Alltag – Das Windows-Pendant zur Linux-Shell
• Troubleshooting-Methodik – Strukturiertes Vorgehen bei Problemen

Weiterlernen

• The Linux Command Line (online kostenlos) – das Standardwerk für Einsteiger, kostenlos als PDF
• explainshell.com – Beliebige Shell-Befehle analysieren und erklären lassen
• Linux Befehle Referenz – IONOS Digitalguide – Kompakte Übersicht der wichtigsten Terminalbefehle
• Ubuntu Server Guide (offizielle Doku) – Offizielle Ubuntu-Serverdokumentation auf Englisch
• Debian Reference Manual – Umfassende Debian-Referenz
• tldr.sh – Vereinfachte Man-Pages mit echten Beispielen (auch als CLI-Tool installierbar)
• GNU sed Manual – Offizielle Referenz für sed
• GNU awk (gawk) Manual – Offizielle Referenz für awk
• tmux Cheat Sheet – Übersicht aller Tastenkombinationen
• rsync man page – Vollständige Optionsreferenz für rsync

Videos

YouTube

YouTube