Linux-Variablen exportieren

Einführung

Umgebungsvariablen spielen in Linux-Betriebssystemen eine entscheidende Rolle. Es handelt sich um dynamische Werte, die die auf dem System laufenden Prozesse beeinflussen. In diesem Lab werden wir untersuchen, wie man den Befehl export unter Linux verwendet, um Umgebungsvariablen zu erstellen und zu verwalten.

Umgebungsvariablen werden in vielen Szenarien eingesetzt, etwa zum Speichern von Konfigurationsinformationen, zur Kommunikation zwischen Prozessen und zur Definition systemweiter Einstellungen. Das Verständnis für den Umgang mit Umgebungsvariablen ist eine grundlegende Fähigkeit für jeden Linux-Anwender oder Systemadministrator.

Dieses Lab führt Sie durch die Grundlagen des Setzens von Variablen, deren Exportierung, um sie für untergeordnete Prozesse (Child Processes) verfügbar zu machen, sowie deren Verwendung in Bash-Skripten. Sie werden lernen, wie diese Variablen genutzt werden können, um dynamischere und konfigurierbare Anwendungen zu erstellen.

Grundlegende Variablen unter Linux verstehen

In diesem Schritt lernen Sie die Grundlagen der Erstellung und Verwendung von Variablen in einer Linux-Shell-Umgebung kennen.

Unter Linux werden Variablen verwendet, um Daten zu speichern, auf die Befehle und Skripte zugreifen und die sie manipulieren können. Eine Variable ist einfach ein Name, der für einen Wert steht.

Beginnen wir mit der Erstellung einer einfachen Variablen in Ihrer Shell:

name="LinuxLearner"

Dieser Befehl erstellt eine Variable namens name und weist ihr den Wert "LinuxLearner" zu. Beachten Sie, dass bei der Zuweisung von Werten an Variablen keine Leerzeichen um das Gleichheitszeichen stehen dürfen.

Um den Wert einer Variablen anzuzeigen, verwenden Sie den Befehl echo, wobei dem Variablennamen ein Dollarzeichen ($) vorangestellt wird:

echo $name

Sie sollten die folgende Ausgabe sehen:

LinuxLearner

Sie können Variablen auch innerhalb von Zeichenketten (Strings) verwenden:

echo "Hello, $name!"

Ausgabe:

Hello, LinuxLearner!

Erstellen Sie nun eine weitere Variable, um Ihre Lieblingsfarbe zu speichern:

color="blue"

Geben Sie eine Nachricht aus, die beide Variablen verwendet:

echo "Hello $name, I see your favorite color is $color."

Ausgabe:

Hello LinuxLearner, I see your favorite color is blue.

Diese von Ihnen erstellten Variablen werden als "Shell-Variablen" oder "lokale Variablen" bezeichnet. Sie sind nur in der aktuellen Shell-Sitzung verfügbar. Im nächsten Schritt lernen wir, wie man Variablen mithilfe des Befehls export für andere Prozesse verfügbar macht.

Variablen als Umgebungsvariablen exportieren

Im vorherigen Schritt haben Sie Shell-Variablen erstellt, die nur in Ihrer aktuellen Shell-Sitzung verfügbar sind. In diesem Schritt lernen Sie, wie Sie den Befehl export verwenden, um eine Shell-Variable in eine Umgebungsvariable umzuwandeln, die für untergeordnete Prozesse verfügbar ist.

Lassen Sie uns zunächst den Unterschied verstehen:

Shell-Variable: Nur in der aktuellen Shell verfügbar.
Umgebungsvariable: Verfügbar für die aktuelle Shell und alle ihre untergeordneten Prozesse.

Um dies zu demonstrieren, erstellen wir eine neue Shell-Variable:

greeting="Welcome to Linux"

Erstellen wir nun ein neues Shell-Skript, das versucht, auf diese Variable zuzugreifen. Öffnen Sie einen Texteditor und erstellen Sie eine Datei namens test_var.sh im Verzeichnis ~/project:

cd ~/project
nano test_var.sh

Fügen Sie den folgenden Inhalt in die Datei ein:

#!/bin/bash
echo "The greeting is: $greeting"

Speichern Sie die Datei (drücken Sie Strg+O, dann Enter) und beenden Sie nano (drücken Sie Strg+X).

Machen Sie das Skript ausführbar:

chmod +x ~/project/test_var.sh

Führen Sie nun das Skript aus:

~/project/test_var.sh

Sie sehen die Ausgabe:

The greeting is:

Beachten Sie, dass der Variablenwert nicht angezeigt wird, da Shell-Variablen nicht an untergeordnete Prozesse weitergegeben werden.

Um diese Variable für das Skript verfügbar zu machen, müssen Sie sie exportieren:

export greeting="Welcome to Linux"

Führen Sie das Skript nun erneut aus:

~/project/test_var.sh

Diesmal sollten Sie sehen:

The greeting is: Welcome to Linux

Herzlichen Glückwunsch! Sie haben erfolgreich eine Variable exportiert und sie zu einer Umgebungsvariable gemacht, auf die andere Prozesse zugreifen können.

Sie können alle aktuellen Umgebungsvariablen mit dem Befehl env überprüfen:

env

Dies zeigt eine Liste aller Umgebungsvariablen in Ihrer aktuellen Sitzung an.

Sie können auch eine bestimmte Umgebungsvariable mit dem Befehl echo überprüfen:

echo $greeting

Lassen Sie uns nun eine weitere Umgebungsvariable erstellen und exportieren:

export USER_LEVEL="beginner"

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob sie gesetzt wurde:

echo $USER_LEVEL

Ausgabe:

beginner

Skripte erstellen, die Umgebungsvariablen verwenden

In diesem Schritt lernen Sie, wie Sie Skripte erstellen und ausführen, die Umgebungsvariablen zur Konfiguration nutzen. Dies ist eine gängige Praxis in der Softwareentwicklung, um Anwendungen flexibler und konfigurierbarer zu machen, ohne den Code ändern zu müssen.

Erstellen wir zunächst ein Skript, das Umgebungsvariablen verwendet, um seine Ausgabe anzupassen. Erstellen Sie eine neue Datei namens greet.sh im Verzeichnis ~/project:

cd ~/project
nano greet.sh

Fügen Sie den folgenden Inhalt in die Datei ein:

#!/bin/bash
## This script demonstrates using environment variables

## Default values if environment variables are not set
DEFAULT_NAME="Guest"
DEFAULT_LANGUAGE="English"

## Use environment variables or default values
USER_NAME=${USER_NAME:-$DEFAULT_NAME}
LANGUAGE=${LANGUAGE:-$DEFAULT_LANGUAGE}

## Greet based on language
if [ "$LANGUAGE" = "English" ]; then
  echo "Hello, $USER_NAME! Welcome to the Linux learning environment."
elif [ "$LANGUAGE" = "Spanish" ]; then
  echo "Hola, $USER_NAME! Bienvenido al entorno de aprendizaje de Linux."
elif [ "$LANGUAGE" = "French" ]; then
  echo "Bonjour, $USER_NAME! Bienvenue dans l'environnement d'apprentissage Linux."
else
  echo "Hello, $USER_NAME! Welcome to the Linux learning environment."
fi

Speichern Sie die Datei (drücken Sie Strg+O, dann Enter) und beenden Sie nano (drücken Sie Strg+X).

Machen Sie das Skript ausführbar:

chmod +x ~/project/greet.sh

Führen Sie nun das Skript aus, ohne Umgebungsvariablen zu setzen:

~/project/greet.sh

Ausgabe:

Hello, Guest! Welcome to the Linux learning environment.

Das Skript hat die Standardwerte verwendet, da keine Umgebungsvariablen gesetzt waren. Lassen Sie uns einige Umgebungsvariablen setzen und das Skript erneut ausführen:

export USER_NAME="LinuxExplorer"
export LANGUAGE="Spanish"

Führen Sie das Skript nun erneut aus:

~/project/greet.sh

Ausgabe:

Hola, LinuxExplorer! Bienvenido al entorno de aprendizaje de Linux.

Beachten Sie, wie sich die Skriptausgabe basierend auf den von uns gesetzten Umgebungsvariablen geändert hat. Dies zeigt, wie Umgebungsvariablen verwendet werden können, um das Anwendungsverhalten zu konfigurieren, ohne den Code zu modifizieren.

Versuchen wir es mit einer anderen Sprache:

export LANGUAGE="French"
~/project/greet.sh

Ausgabe:

Bonjour, LinuxExplorer! Bienvenue dans l'environnement d'apprentissage Linux.

Dieser Ansatz wird in der Softwarekonfiguration häufig verwendet, um Anwendungen flexibler und anpassungsfähiger an verschiedene Umgebungen zu machen.

Fortgeschrittene Nutzung und temporäre Umgebungsvariablen

In diesem Schritt lernen Sie, wie Sie Umgebungsvariablen für einen einzelnen Befehl setzen, ohne die globale Umgebung zu ändern, und wie Sie fortgeschrittenere Methoden für Umgebungsvariablen implementieren.

Umgebungsvariablen für einen einzelnen Befehl setzen

Manchmal möchten Sie eine Umgebungsvariable nur für einen einzigen Befehl setzen. Dies können Sie tun, indem Sie dem Befehl die Zuweisungen der Umgebungsvariablen voranstellen:

LANGUAGE="Spanish" ~/project/greet.sh

Beachten Sie, dass das Skript mit der Spracheinstellung "Spanish" ausgeführt wird, die globale Umgebungsvariable sich jedoch nicht geändert hat:

echo $LANGUAGE

Ausgabe:

French

Dies liegt daran, dass die Umgebungsvariable nur für die Dauer des Befehls gesetzt wurde.

Umgebungsvariablen in einem realen Szenario

Lassen Sie uns ein praktischeres Beispiel erstellen – ein Konfigurationsskript für eine hypothetische Anwendung. Erstellen Sie eine neue Datei namens app_config.sh:

cd ~/project
nano app_config.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash
## Application configuration script

## Display the current configuration
echo "Current Application Configuration:"
echo "--------------------------------"
echo "App Name: ${APP_NAME:-Unknown}"
echo "App Version: ${APP_VERSION:-0.0.0}"
echo "Log Level: ${LOG_LEVEL:-INFO}"
echo "Database URL: ${DB_URL:-localhost:5432}"
echo "API Key: ${API_KEY:-not set}"
echo "--------------------------------"

## Check if required configurations are set
if [[ -z "$APP_NAME" ]]; then
  echo "WARNING: APP_NAME is not set. Some features may not work properly."
fi

if [[ -z "$API_KEY" ]]; then
  echo "WARNING: API_KEY is not set. API functionality will be limited."
fi

## Validate log level
valid_log_levels=("DEBUG" "INFO" "WARNING" "ERROR" "CRITICAL")
log_level=${LOG_LEVEL:-INFO}
valid=false

for level in "${valid_log_levels[@]}"; do
  if [[ "$level" == "$log_level" ]]; then
    valid=true
    break
  fi
done

if [[ "$valid" == false ]]; then
  echo "ERROR: Invalid LOG_LEVEL '$log_level'. Must be one of: ${valid_log_levels[*]}"
  exit 1
fi

echo "Configuration validation complete."

Speichern Sie die Datei (drücken Sie Strg+O, dann Enter) und beenden Sie nano (drücken Sie Strg+X).

Machen Sie das Skript ausführbar:

chmod +x ~/project/app_config.sh

Führen Sie nun das Skript aus, ohne Umgebungsvariablen zu setzen:

~/project/app_config.sh

Sie sollten Warnungen über fehlende Konfigurationen sehen.

Setzen Sie nun alle erforderlichen Umgebungsvariablen und führen Sie das Skript erneut aus:

export APP_NAME="MyAwesomeApp"
export APP_VERSION="1.0.0"
export LOG_LEVEL="DEBUG"
export DB_URL="postgres://user:password@dbserver:5432/mydb"
export API_KEY="abc123xyz456"

~/project/app_config.sh

Sie sollten alle Konfigurationswerte ordnungsgemäß und ohne Warnungen angezeigt bekommen.

Versuchen Sie, einen ungültigen Log-Level zu setzen:

export LOG_LEVEL="VERBOSE"
~/project/app_config.sh

Das Skript sollte eine Fehlermeldung für den ungültigen Log-Level anzeigen.

Dieses Beispiel zeigt, wie Umgebungsvariablen für die Anwendungskonfiguration verwendet werden können, inklusive Validierung und Standardwerten.

Umgebungsvariablen dauerhaft speichern

Bisher haben wir Umgebungsvariablen gesetzt, die nur für die aktuelle Terminal-Sitzung gültig waren. Sobald Sie Ihr Terminal schließen oder sich abmelden, gehen diese Variablen verloren. In diesem Schritt lernen Sie, wie Sie Umgebungsvariablen sitzungsübergreifend dauerhaft machen.

Umgebungsvariablen in Konfigurationsdateien speichern

Es gibt verschiedene Dateien, in denen Sie Umgebungsvariablen setzen können, um sie dauerhaft zu machen:

~/.bashrc oder ~/.zshrc: Für benutzerspezifische Variablen.
/etc/environment: Für systemweite Variablen.
/etc/profile oder Dateien in /etc/profile.d/: Für systemweite Variablen, die beim Login geladen werden.

Fügen wir einige Umgebungsvariablen zur Shell-Konfigurationsdatei Ihres Benutzers hinzu. Da diese Lab-Umgebung ZSH verwendet, bearbeiten wir die Datei ~/.zshrc:

nano ~/.zshrc

Scrollen Sie zum Ende der Datei und fügen Sie die folgenden Zeilen hinzu:

## Custom environment variables
export EDITOR="nano"
export CUSTOM_PATH="$HOME/bin"
export GREETING="Hello from .zshrc!"

Speichern Sie die Datei (drücken Sie Strg+O, dann Enter) und beenden Sie nano (drücken Sie Strg+X).

Um diese Änderungen auf Ihre aktuelle Sitzung anzuwenden, müssen Sie die Datei neu laden (source):

source ~/.zshrc

Überprüfen Sie nun, ob die Variablen gesetzt sind:

echo $EDITOR
echo $CUSTOM_PATH
echo $GREETING

Sie sollten die Werte sehen, die Sie in der .zshrc-Datei festgelegt haben.

Diese Umgebungsvariablen sind nun bei jedem Start einer neuen Shell-Sitzung verfügbar.

Eine benutzerdefinierte Datei für Umgebungsvariablen erstellen

Eine bewährte Methode zur Verwaltung von Umgebungsvariablen besteht darin, eine separate Datei nur für diese Variablen zu erstellen, insbesondere für projektspezifische Variablen. Dies erleichtert die Verwaltung und Weitergabe von Konfigurationen.

Erstellen wir eine Datei namens .env in Ihrem Projektverzeichnis:

cd ~/project
nano .env

Fügen Sie den folgenden Inhalt hinzu:

## Project environment variables
export PROJECT_NAME="Linux Environment Lab"
export PROJECT_VERSION="1.0.0"
export DEBUG_MODE="true"

Speichern Sie die Datei (drücken Sie Strg+O, dann Enter) und beenden Sie nano (drücken Sie Strg+X).

Um diese Variablen in Ihre aktuelle Sitzung zu laden, führen Sie source auf die Datei aus:

source ~/project/.env

Überprüfen Sie nun, ob die Variablen gesetzt sind:

echo $PROJECT_NAME
echo $PROJECT_VERSION
echo $DEBUG_MODE

Sie sollten die Werte aus der .env-Datei sehen.

Ein Skript zum Laden von Umgebungsvariablen erstellen

Erstellen wir abschließend ein Skript, das Umgebungsvariablen aus einer Datei lädt. Dies ist ein gängiges Muster in Entwicklungsumgebungen:

cd ~/project
nano load_env.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash
## Script to load environment variables from a .env file

ENV_FILE=".env"

if [[ -f "$ENV_FILE" ]]; then
  echo "Loading environment variables from $ENV_FILE"

  ## Read each line from the .env file
  while IFS= read -r line || [[ -n "$line" ]]; do
    ## Skip comments and empty lines
    if [[ $line =~ ^## ]] || [[ -z $line ]]; then
      continue
    fi

    ## Export the variable if it starts with "export "
    if [[ $line == export* ]]; then
      ## Remove the "export " prefix and export the variable
      eval "${line}"
      echo "Exported: ${line#export }"
    fi
  done < "$ENV_FILE"

  echo "Environment variables loaded successfully"
else
  echo "Error: $ENV_FILE file not found"
  exit 1
fi

Speichern Sie die Datei (drücken Sie Strg+O, dann Enter) und beenden Sie nano (drücken Sie Strg+X).

Machen Sie das Skript ausführbar:

chmod +x ~/project/load_env.sh

Heben Sie nun die zuvor gesetzten Variablen auf (unset) und führen Sie dann das Skript aus, um sie erneut zu laden:

unset PROJECT_NAME PROJECT_VERSION DEBUG_MODE
echo "PROJECT_NAME: $PROJECT_NAME"

## Now load the variables using the script
~/project/load_env.sh

## Check if the variables are now set
echo "PROJECT_NAME: $PROJECT_NAME"

Das Skript liest die .env-Datei und exportiert jede Variable, die mit dem Schlüsselwort export definiert wurde.

Dieser Ansatz wird in Entwicklungsumgebungen häufig verwendet, um projektspezifische Umgebungsvariablen zu verwalten.

Zusammenfassung

In diesem Lab haben Sie die wesentlichen Konzepte für den Umgang mit Umgebungsvariablen unter Linux kennengelernt:

Grundlegende Variablen: Sie haben gelernt, wie man Shell-Variablen in der aktuellen Sitzung erstellt und verwendet.
Umgebungsvariablen: Sie haben entdeckt, wie man den Befehl export verwendet, um Shell-Variablen in Umgebungsvariablen umzuwandeln, auf die untergeordnete Prozesse zugreifen können.
Verwendung von Variablen in Skripten: Sie haben Skripte erstellt, die Umgebungsvariablen lesen und verwenden, um ihr Verhalten anzupassen, ohne den Code zu ändern.
Fortgeschrittene Nutzung: Sie haben fortgeschrittene Techniken erkundet, wie das Setzen von Variablen für einen einzelnen Befehl und die Validierung von Variablenwerten in Skripten.
Persistente Variablen: Sie haben gelernt, wie man Umgebungsvariablen dauerhaft macht, indem man sie in Konfigurationsdateien einträgt und Hilfsskripte zu deren Laden erstellt.

Umgebungsvariablen sind eine leistungsstarke Funktion unter Linux, die es Ihnen ermöglicht, Anwendungen zu konfigurieren, Daten zwischen Prozessen auszutauschen und Ihre Umgebung anzupassen. Sie werden in der Softwareentwicklung, der Systemadministration und bei der Anwendungsbereitstellung umfassend eingesetzt.

Durch die Beherrschung von Umgebungsvariablen haben Sie eine wichtige Fähigkeit erworben, die Ihnen auf Ihrer Linux-Reise von persönlichen Projekten bis hin zur Systemadministration auf Unternehmensebene von großem Nutzen sein wird.