Linux-Umgebungsvariablen: Von den Grundlagen bis zur fortgeschrittenen Anwendung

Einführung

Willkommen zu diesem praxisorientierten Lab über Umgebungsvariablen in Linux! Umgebungsvariablen sind dynamische Werte, die das Verhalten von laufenden Prozessen auf einem Computer beeinflussen können. Sie spielen eine entscheidende Rolle bei der Systemkonfiguration und der Programmausführung. Durch die Beherrschung von Umgebungsvariablen erwerben Sie essenzielle Fähigkeiten für die Linux-Systemadministration und die Softwareentwicklung.

In diesem Lab lernen Sie, wie Sie Umgebungsvariablen erstellen, anzeigen, ändern und löschen. Wir werden auch untersuchen, wie Sie diese Änderungen dauerhaft machen und einige der wichtigsten integrierten Umgebungsvariablen in Linux kennenlernen. Egal, ob Sie Anfänger sind oder Ihr Verständnis festigen möchten, dieses Lab bietet Ihnen wertvolle praktische Erfahrung.

Legen wir los!

Variablen in Linux verstehen

Bevor wir uns mit Umgebungsvariablen befassen, beginnen wir mit einfachen Shell-Variablen. Dies wird Ihnen helfen, das grundlegende Konzept von Variablen in Linux zu verstehen.

Öffnen Sie Ihr Terminal. Sie sollten sich im Verzeichnis /home/labex/project befinden. Falls nicht, können Sie mit dem folgenden Befehl in dieses Verzeichnis wechseln:
```
cd /home/labex/project
```
Erstellen wir nun eine einfache Shell-Variable. In Linux können Sie eine Variable erstellen, indem Sie einem Namen einfach einen Wert zuweisen. Wir erstellen eine Variable namens my_var:
```
my_var="Hello, Linux"
```
Wichtiger Hinweis: Bei der Zuweisung von Variablen in Bash (und Zsh, die wir in diesem Lab verwenden) dürfen keine Leerzeichen um das Gleichheitszeichen (=) stehen. my_var = "Hello, Linux" oder my_var= "Hello, Linux" führt zu einem Fehler.
Um den Wert der Variable anzuzeigen, verwenden wir den Befehl echo mit einem vorangestellten $ vor dem Variablennamen. Das $ weist die Shell an, den Wert der Variable einzusetzen:
```
echo $my_var
```
Sie sollten die folgende Ausgabe sehen:
```
Hello, Linux
```
Sie können Variablen auch innerhalb anderer Befehle oder Zuweisungen verwenden. Zum Beispiel:
```
echo "The value of my_var is: $my_var"
```
Dies gibt aus: The value of my_var is: Hello, Linux

Gute Arbeit! Sie haben gerade Ihre erste Shell-Variable erstellt und verwendet. Diese Variable ist jedoch nur in der aktuellen Shell-Sitzung verfügbar. Wenn Sie ein neues Terminalfenster oder einen neuen Tab öffnen, wird diese Variable dort nicht vorhanden sein. Hier kommen Umgebungsvariablen ins Spiel.

Einführung in Umgebungsvariablen

Nachdem wir die Grundlagen von Variablen verstanden haben, schauen wir uns nun Umgebungsvariablen an. Umgebungsvariablen sind Variablen, die jedem Kindprozess der Shell zur Verfügung stehen. Das bedeutet, dass Skripte und Programme, die von dieser Shell aus gestartet werden, auf sie zugreifen können.

Um alle aktuellen Umgebungsvariablen anzuzeigen, verwenden Sie den Befehl env:
```
env
```
Dies zeigt eine lange Liste von Variablen an. Keine Sorge, wenn Sie noch nicht alle verstehen – wir werden die wichtigsten später besprechen.
Eine der bedeutendsten Umgebungsvariablen ist PATH. Schauen wir sie uns an:
```
echo $PATH
```
Die PATH-Variable listet Verzeichnisse auf, in denen das System nach ausführbaren Programmen sucht. Die einzelnen Verzeichnisse sind durch einen Doppelpunkt (:) getrennt.
Erstellen wir nun unsere eigene Umgebungsvariable. Wir verwenden den Befehl export, um eine Umgebungsvariable zu deklarieren:
```
export MY_ENV_VAR="This is an environment variable"
```
Der Befehl export macht die Variable für Kindprozesse verfügbar. Dies ist der entscheidende Unterschied zwischen Shell-Variablen und Umgebungsvariablen.
Um diesen Unterschied zu verdeutlichen, erstellen wir ein Shell-Skript, das versucht, sowohl auf eine reguläre Shell-Variable als auch auf eine Umgebungsvariable zuzugreifen. Wir nutzen dazu ein heredoc mit dem Befehl cat, eine gängige Methode, um mehrzeilige Inhalte in eine Datei zu schreiben:
```
cat << 'EOF' > test_vars.sh
#!/bin/bash
echo "Shell variable: $my_var"
echo "Environment variable: $MY_ENV_VAR"
EOF
```
Machen Sie das Skript ausführbar:
```
chmod +x test_vars.sh
```
Führen Sie das Skript nun aus:
```
./test_vars.sh
```
Sie werden sehen, dass auf die Umgebungsvariable (MY_ENV_VAR) zugegriffen werden kann, während die Shell-Variable (my_var) leer bleibt. Das liegt daran, dass my_var nicht exportiert wurde und Kindprozesse (wie das Skript) sie daher nicht kennen.
Um zu überprüfen, ob MY_ENV_VAR nun tatsächlich eine Umgebungsvariable ist, können wir erneut den Befehl env verwenden, filtern aber die Ausgabe mit grep:
```
env | grep MY_ENV_VAR
```
Ihre neue Variable sollte in der Ausgabe erscheinen.
Sie können den Wert Ihrer neuen Umgebungsvariable auch direkt abfragen:
```
echo $MY_ENV_VAR
```

Hervorragend! Sie haben nun Ihre erste Umgebungsvariable erstellt und den Unterschied zu einer Shell-Variable gesehen. Der Hauptunterschied besteht darin, dass Umgebungsvariablen, die mit export erstellt wurden, an Kindprozesse weitergegeben werden.

Umgebungsvariablen und Shell-Variablen haben jeweils ihren eigenen Gültigkeitsbereich (Scope). Wenn Sie eine Variable exportieren (z. B. export MY_ENV_VAR="etwas"), steht sie jedem Subprozess zur Verfügung, der von dieser Shell aus gestartet wird. Wenn Sie jedoch eine völlig separate Shell-Sitzung öffnen, erbt diese die Variablen Ihrer aktuellen Shell nicht, es sei denn, Sie haben sie in einer Konfigurationsdatei (wie .zshrc oder .bashrc) hinterlegt.

Zusammenfassend:

Eine reguläre Shell-Variable ist nur innerhalb der aktuellen Sitzung sichtbar.
Eine exportierte Variable steht Kindprozessen zur Verfügung, die aus dieser Sitzung gestartet werden.
Eine Variable in einer Shell-Startdatei (wie .zshrc) wird auf alle neuen Sitzungen dieser Shell angewendet.

Sie können die Variablen eines anderen Benutzers oder einer anderen Shell nicht direkt lesen, da jeder Prozess seine eigene Umgebung verwaltet.

In den folgenden Schritten lernen wir, wie man Umgebungsvariablen dauerhaft einrichtet.

Beständigkeitsebenen von Variablen

Um die Unterschiede zwischen diesen Variablentypen und ihrer Beständigkeit zu veranschaulichen, finden Sie hier eine Übersicht:

graph LR
    A["Linux Variablentypen"] --> B["Shell-Variable"]
    A --> C["Umgebungsvariable"]
    A --> D["Permanente Variable"]

    B --> B1["Nur Sitzung"]
    B --> B2["Nicht vererbt"]
    B --> B3["Verloren bei Beendigung"]

    C --> C1["Sitzungsbereich"]
    C --> C2["Zugriff für Kinder"]
    C --> C3["Verloren bei Beendigung"]

    D --> D1["Alle Sitzungen"]
    D --> D2["Zugriff für Kinder"]
    D --> D3["Persistent"]

    B1 --> E1["my_var='value'"]
    C2 --> E2["export VAR='value'"]
    D3 --> E3["~/.zshrc Datei"]

    style B fill:#ffebee
    style C fill:#fff3e0
    style D fill:#e8f5e8

Dieses Diagramm zeigt die drei Ebenen der Beständigkeit. Hier ist eine Zusammenfassung zur schnellen Referenz:

Variablentyp	Gültigkeitsbereich	Zugriff für Kindprozesse	Beständigkeit	Syntax-Beispiel
Shell-Variable	Nur aktuelle Sitzung	Nein	Weg nach Beendigung	`my_var='value'`
Umgebungsvariable	Aktuelle Sitzung	Ja	Weg nach Beendigung	`export VAR='value'`
Permanente Variable	Alle neuen Sitzungen	Ja	Bleibt nach Beendigung	In `~/.zshrc` Datei

Das Verständnis dieser drei Ebenen ist entscheidend für eine effektive Linux-Systemadministration.

Die Umgebungsvariable PATH ändern

Die PATH-Variable ist eine der wichtigsten Umgebungsvariablen in Linux. Sie teilt dem System mit, in welchen Verzeichnissen es nach ausführbaren Dateien suchen soll. Wir werden sie nun erweitern, um ein neues Verzeichnis einzuschließen.

Erstellen wir zunächst ein neues Verzeichnis, in dem wir eigene Skripte speichern können:
```
mkdir ~/my_scripts
```
Dies erstellt ein Verzeichnis namens my_scripts in Ihrem Home-Verzeichnis. Das Symbol ~ ist eine Abkürzung für den Pfad Ihres Home-Verzeichnisses, in diesem Lab also /home/labex.
Nun fügen wir dieses neue Verzeichnis zu Ihrem PATH hinzu. Wir verwenden wieder den Befehl export, modifizieren diesmal aber eine bestehende Variable:
```
export PATH="$PATH:$HOME/my_scripts"
```
Erklärung der Bestandteile:
- $PATH ist der aktuelle Wert der PATH-Umgebungsvariable. Wir nehmen den bestehenden Wert und hängen etwas an.
- : dient als Trennzeichen zwischen den Verzeichnissen im PATH. Ohne den Doppelpunkt kann die Shell die Programme im neuen Verzeichnis nicht finden.
- $HOME ist eine Umgebungsvariable, die auf Ihr Home-Verzeichnis zeigt.
- Wir hängen also :$HOME/my_scripts an den bestehenden PATH an. Das System sucht nun in my_scripts, nachdem es die Verzeichnisse im ursprünglichen PATH durchsucht hat.
Überprüfen Sie, ob das neue Verzeichnis hinzugefügt wurde:
```
echo $PATH
```
Sie sollten /home/labex/my_scripts am Ende der Ausgabe sehen.
Um dies zu testen, erstellen wir ein einfaches Skript in unserem neuen Verzeichnis:
```
cat << 'EOF' > ~/my_scripts/hello.sh
#!/bin/zsh
echo "Hello from my custom script!"
EOF
```
Dies erstellt ein Shell-Skript namens hello.sh. Die erste Zeile #!/bin/zsh (Shebang) teilt dem System mit, dass dies ein Zsh-Skript ist.
Machen Sie das Skript ausführbar:
```
chmod +x ~/my_scripts/hello.sh
```
Der Befehl chmod +x vergibt Ausführungsrechte. Ohne diesen Schritt würden Sie eine Fehlermeldung "Permission denied" erhalten.
Jetzt sollten Sie in der Lage sein, dieses Skript von überall aus aufzurufen, indem Sie einfach seinen Namen eingeben:
```
hello.sh
```
Wenn alles korrekt funktioniert hat, sehen Sie: Hello from my custom script!

Dies funktioniert, weil wir das Verzeichnis my_scripts zum PATH hinzugefügt haben. Wenn Sie einen Befehl eingeben, durchsucht die Shell der Reihe nach alle im PATH gelisteten Verzeichnisse nach einer ausführbaren Datei mit diesem Namen.

Zur Demonstration wechseln wir in ein anderes Verzeichnis und führen das Skript erneut aus:

cd /tmp
hello.sh

Das Skript läuft weiterhin, obwohl Sie sich nicht in seinem Verzeichnis befinden. Das ist die Stärke der PATH-Variable.

Gute Arbeit! Sie haben die PATH-Variable erfolgreich geändert und ein benutzerdefiniertes Skript erstellt, das systemweit aufrufbar ist.

Umgebungsvariablen dauerhaft machen

Die bisher gesetzten Umgebungsvariablen gehen verloren, sobald Sie das Terminal schließen. Um sie dauerhaft zu speichern, müssen wir sie in eine Shell-Konfigurationsdatei eintragen. Die Datei hängt von der verwendeten Shell ab.

In dieser Lab-Umgebung verwenden wir die Z-Shell (zsh). Zsh ist eine erweiterte Version der Bourne Shell (sh) mit vielen Verbesserungen und ist mittlerweile die Standard-Shell in macOS.

Würden Sie Bash verwenden, müssten Sie die Datei .bashrc bearbeiten. Da wir Zsh nutzen, bearbeiten wir die Datei .zshrc. Es ist sehr wichtig, die richtige Datei zu verwenden. Wenn Sie die .bashrc ändern, während Sie zsh nutzen, werden die Variablen nicht geladen.

Öffnen Sie die Datei .zshrc in Ihrem Home-Verzeichnis mit einem Texteditor. Wir verwenden nano, einen einfachen terminalbasierten Editor:
```
nano ~/.zshrc
```
Diese Datei wird jedes Mal ausgeführt, wenn Sie eine neue Terminal-Sitzung starten.
Scrollen Sie mit den Pfeiltasten ganz nach unten und fügen Sie die folgenden Zeilen hinzu:
```
export MY_ENV_VAR="This is an environment variable"
export PATH="$PATH:$HOME/my_scripts"
```
Achten Sie darauf, dass keine Leerzeichen um das = stehen.
Speichern und beenden Sie den Editor. In nano drücken Sie dazu Strg+X, dann Y (zum Bestätigen) und schließlich Enter.
Um die Änderungen sofort anzuwenden, ohne das Terminal neu zu starten, verwenden wir den Befehl source:
```
source ~/.zshrc
```
Der Befehl source liest und führt die Befehle aus der angegebenen Datei in der aktuellen Shell-Umgebung aus. Würden Sie die Datei einfach mit bash ~/.zshrc ausführen, geschähe dies in einer neuen Shell und hätte keine Auswirkungen auf Ihre aktuelle Sitzung. Wenn Sie diesen Schritt überspringen, werden die Änderungen in Ihrem aktuellen Terminal nicht wirksam.

Ab jetzt werden diese Variablen bei jedem Öffnen eines neuen Terminals automatisch gesetzt.

Wichtige integrierte Umgebungsvariablen verstehen

Linux verfügt über mehrere integrierte Umgebungsvariablen, die für den Systembetrieb entscheidend sind. Schauen wir uns einige davon an:

HOME: Zeigt auf das Home-Verzeichnis des aktuellen Benutzers.
```
echo $HOME
```
USER: Enthält den Benutzernamen des aktuellen Benutzers.
```
echo $USER
```
SHELL: Gibt die Standard-Shell des Benutzers an.
```
echo $SHELL
```
PWD: Steht für "Print Working Directory" und enthält den Pfad des aktuellen Verzeichnisses.
```
echo $PWD
```
TERM: Gibt den Terminaltyp an, der emuliert werden soll.
```
echo $TERM
```

Das Verständnis dieser Variablen hilft Ihnen, sich in Ihrer Linux-Umgebung besser zurechtzufinden.

Umgebungsvariablen löschen

Manchmal müssen Sie eine Umgebungsvariable entfernen. Dies geschieht mit dem Befehl unset.

Prüfen wir zunächst, ob MY_ENV_VAR noch gesetzt ist:
```
echo $MY_ENV_VAR
```
Um die Variable zu löschen, verwenden Sie unset:
```
unset MY_ENV_VAR
```
Überprüfen Sie die Löschung:
```
echo $MY_ENV_VAR
```
Es sollte keine Ausgabe erscheinen, was bedeutet, dass die Variable nicht mehr existiert.
Sie können auch die Option -v verwenden, um sicherzustellen, dass Sie eine Variable und keine Shell-Funktion löschen:
```
unset -v MY_ENV_VAR
```

Beachten Sie: Wenn Sie die Variable in Ihre .zshrc-Datei eingetragen haben, wird sie beim nächsten Start eines Terminals oder beim erneuten Ausführen von source wieder erstellt.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben dieses umfassende Lab über Linux-Umgebungsvariablen abgeschlossen. Hier ist ein Rückblick auf das, was Sie gelernt haben:

Sie haben einfache Shell-Variablen erstellt und deren begrenzten Gültigkeitsbereich verstanden.
Sie haben Umgebungsvariablen kennengelernt und erfahren, wie sie sich durch den Befehl export von Shell-Variablen unterscheiden, insbesondere im Hinblick auf die Vererbung an Kindprozesse.
Sie haben die wichtige PATH-Variable modifiziert, um eigene Skripte systemweit ausführbar zu machen, und dabei die Bedeutung des Trennzeichens : gelernt.
Sie haben Umgebungsvariablen durch Einträge in der .zshrc dauerhaft gemacht und den Unterschied zwischen Bash- und Zsh-Konfigurationen sowie die Funktion von source verstanden.
Sie haben einige der wichtigsten vordefinierten Umgebungsvariablen in Linux erkundet.
Schließlich haben Sie gelernt, wie man Variablen mit dem Befehl unset wieder entfernt.

Diese Fähigkeiten sind grundlegend für die Linux-Systemadministration und Softwareentwicklung. Umgebungsvariablen ermöglichen es Ihnen, Ihr System und Ihre Anwendungen flexibel zu konfigurieren. Je mehr Sie mit Linux arbeiten, desto häufiger werden Ihnen Umgebungsvariablen in Skripten und bei der Systemkonfiguration begegnen.

Denken Sie daran: Übung macht den Meister. Versuchen Sie, eigene Variablen für verschiedene Zwecke zu erstellen und beobachten Sie, wie Anwendungen darauf reagieren. Viel Erfolg beim weiteren Lernen!