Umgebungsvariablen sind benannte Werte, die Programme beim Start von der Shell erben — etwa Suchpfade, Editor oder Sprache. Die env-Befehle zeigen diese Variablen an, setzen sie für einzelne Aufrufe und helfen bei der Fehlersuche.

Variablen anzeigen

env                 # zeigt alle exportierten Umgebungsvariablen
env | sort          # sortierte Übersicht
printenv PATH       # zeigt den Wert einer einzelnen Variable
echo $PATH          # Alternative: Wert direkt ausgeben

Variablen setzen und exportieren

Eine Variable existiert zunächst nur in der aktuellen Shell. Erst export macht sie für Kindprozesse sichtbar:

EDITOR=nano                     # nur in der Shell, nicht vererbt
export EDITOR=nano              # wird an Kindprozesse vererbt
export PATH="$PATH:/opt/bin"    # Pfad erweitern (alten Wert mit $PATH übernehmen!)
env EDITOR=vim crontab -e       # Variable nur für diesen einen Aufruf

Wichtige Umgebungsvariablen

• PATH — Verzeichnisse, in denen die Shell nach ausführbaren Dateien sucht (durch Doppelpunkte getrennt)
• HOME — das eigene Home-Verzeichnis
• USER / LOGNAME — aktueller Benutzername
• SHELL — die aktive Shell (z.B. /bin/bash)
• LANG / LC_ALL — Sprache und Locale
• EDITOR — bevorzugter Texteditor für viele Programme

Variablen entfernen und prüfen

unset TEMP_VAR      # Variable entfernen
set | grep PATH     # alle Variablen der Shell anzeigen (auch nicht exportierte)
env -i bash         # Shell mit leerer Umgebung starten (Testumgebung)

Der Unterschied ist wichtig: set zeigt auch Shell-lokale Variablen, env und printenv nur exportierte. export -p listet alle aktuell exportierten Variablen im export-Format.

Praxis-Tipps

• Beim Erweitern von PATH immer $PATH mit einschließen, sonst verlieren alle Programme ihren Suchpfad.
• Dauerhafte Einstellungen gehören nach ~/.bashrc (interaktive Shells) oder ~/.profile (Login-Shells).
• Wer die Umgebung eines Programms debuggen will, startet es mit env und prüft die Ausgabe — das deckt fehlende Variablen sofort auf.

Verwandte Grundlagen: Bash-Befehle, chmod, chown und ln, Shell, Variable, Alias, Pipeline, jobs-Befehle.

Job Control ist die Fähigkeit der Bash, Vordergrund- und Hintergrundprozesse zu verwalten. Die jobs-Befehle zeigen laufende oder pausierte Aufgaben an und verschieben sie zwischen Vorder- und Hintergrund.

Prozesse in den Hintergrund schicken

Ein Programm kann direkt im Hintergrund starten, wenn man ein Kaufmanns-Und (&) anhängt. Alternativ pausiert man einen laufenden Vordergrundprozess mit Strg+Z und verschiebt ihn danach:

sleep 300 &          # startet sleep direkt im Hintergrund
top                 # läuft im Vordergrund
# Strg+Z drücken: Prozess wird gestoppt (Status: Stopped)
bg                  # setzt den gestoppten Job im Hintergrund fort
fg                  # holt einen Job zurück in den Vordergrund

Die wichtigsten jobs-Befehle

• jobs — listet alle Jobs mit Job-Nummer, Status und Kommando
• jobs -l — zeigt zusätzlich die Prozess-ID (PID)
• bg %n — setzt Job Nummer n im Hintergrund fort
• fg %n — holt Job Nummer n in den Vordergrund
• kill %n — beendet Job Nummer n (Job-Referenz statt PID)
• wait — wartet, bis alle Hintergrundjobs fertig sind
• disown %n — entfernt den Job aus der Job-Tabelle, sodass er das Terminal nicht mehr blockiert
• nohup — startet ein Programm unempfindlich gegen HUP-Signale, ideal für SSH-Sessions

Job-Nummern richtig lesen

$ sleep 100 &
[1] 2345
$ jobs
[1]+  Running                 sleep 100 &

Die Zahl in eckigen Klammern ist die Job-Nummer, die folgende Zahl die PID. Das Pluszeichen markiert den aktuellen Job, auf den sich fg ohne Argument bezieht.

Praxis-Tipps

• Pausierte Jobs bleiben im Speicher, bis sie fortgesetzt oder beendet werden — vor dem Ausloggen mit jobs prüfen.
• Für echte Parallelität in Skripten eignen sich xargs -P oder eine explizite Warteschlange mit wait.
• Systemd-Dienste statt eigener Hintergrundprozesse verwenden, wenn ein Dienst dauerhaft laufen soll: siehe systemctl und journalctl.

Verwandte Grundlagen: Bash-Befehle, ps, top und kill, grep-Befehle, xargs-Befehle, Pipeline, Variable, history-Befehle.

Die Bash merkt sich jeden eingegebenen Befehl im Befehlsverlauf (History). Der history-Befehl zeigt diesen Verlauf an und macht es leicht, frühere Befehle erneut auszuführen, zu durchsuchen oder zu bearbeiten.

Verlauf anzeigen und erneut ausführen

history             # zeigt die letzten Befehle mit Nummern
history 20          # zeigt nur die letzten 20 Einträge
!!                  # führt den letzten Befehl erneut aus
!42                 # führt Befehl Nummer 42 erneut aus
!grep               # führt den letzten Befehl aus, der mit grep begann
sudo !!             # führt den letzten Befehl mit sudo aus

Im Verlauf suchen und bearbeiten

• Strg+R — interaktive Rückwärtssuche: tippen, Enter zum Ausführen
• Strg+P / Strg+N — vorheriger/nächster Eintrag (alternativ Pfeiltasten)
• fc — öffnet den letzten Befehl im Editor (Standard: nano oder vi)
• fc -l — listet Verlauf wie history, aber ohne Nummern-Formatierung
• history -c — leert den Verlauf der aktuellen Session
• history -d 42 — löscht Eintrag Nummer 42

Verlauf dauerhaft speichern

Die wichtigsten Variablen steuern, wie viel gemerkt wird:

echo $HISTSIZE       # maximale Befehle pro Session (Standard: 1000)
echo $HISTFILESIZE   # maximale Zeilen in der Datei ~/.bash_history
echo $HISTFILE       # Pfad der Verlaufsdatei

Die Datei ~/.bash_history wird beim Beenden der Shell geschrieben. Wer den Verlauf sofort und ohne Duplikate speichern will, setzt in ~/.bashrc:

shopt -s histappend
HISTCONTROL=ignoreboth
PROMPT_COMMAND="history -a"

Praxis-Tipps

• history | grep ssh kombiniert den Verlauf mit der grep-Suche — so findet man vergangene Kommandos schnell wieder.
• Vor !! oder !grep erst history prüfen: falsche Nummern führen den falschen Befehl aus.
• Der Verlauf enthält sensible Daten — bei geteilten Konten history -c verwenden und HISTFILE leeren.

Verwandte Grundlagen: Bash-Befehle, sed-Befehle, Variable, env-Befehle, jobs-Befehle.

head und tail zeigen die ersten beziehungsweise letzten Zeilen einer Datei an. Beide Werkzeuge gehören zur Grundausstattung jeder Linux- und Unix-Shell und sind besonders nützlich, um große Logdateien oder lange Ausgaben gezielt zu untersuchen, ohne sie vollständig zu öffnen.

head: Die ersten Zeilen

Standardmäßig zeigt head die ersten zehn Zeilen einer Datei:

$ head config.ini
[server]
host=localhost
port=8080
log_level=info

Die Anzahl lässt sich mit -n festlegen, Bytes mit -c:

$ head -n 5 config.ini        # die ersten 5 Zeilen
$ head -c 100 datei.bin        # die ersten 100 Bytes

tail: Die letzten Zeilen

tail zeigt standardmäßig die letzten zehn Zeilen — ideal, um in Logs den neuesten Stand zu sehen:

$ tail /var/log/syslog

Mit -n wird die Anzahl angepasst:

$ tail -n 20 /var/log/syslog

Live-Verfolgung mit tail -f

Die wichtigste Option ist tail -f (follow): Der Befehl bleibt aktiv und zeigt neue Zeilen sofort an, sobald sie in die Datei geschrieben werden. Das ist das Standardwerkzeug, um Logdateien in Echtzeit zu beobachten:

$ tail -f /var/log/nginx/access.log

Die Beobachtung endet mit Strg + C. Vergleichbar arbeitet journalctl -f für systemd-Logs — siehe systemctl und journalctl.

head und tail in Pipelines

Beide Werkzeuge sind ideale Filter in Pipelines. Typische Kombinationen:

$ tail -n 100 app.log | grep ERROR        # letzte 100 Zeilen filtern
$ ls -S | head -5                          # die 5 größten Dateien
$ history | tail -20                       # die letzten 20 Befehle

Zusammen mit grep, sort, uniq und cut sowie wc lassen sich so komplette Auswertungen in einer Zeile bauen.

Dateien aus der Mitte lesen

Durch die Kombination beider Befehle wird jede beliebige Textregion erreichbar:

$ head -n 50 datei.txt | tail -n 10       # Zeilen 41–50
$ sed -n "41,50p" datei.txt                # dasselbe mit sed

Für die reine Textfilterung ist sed oft die bessere Wahl, für Dateisuche und Stapelverarbeitung find und xargs.

Verwandte Grundlagen: Bash-Befehle und curl und wget — Letztere kombinieren Downloads oft mit head oder tail, um große Antworten zu begrenzen.