Exportieren von Linux-Variablen

Einführung

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

Umgebungsvariablen werden in vielen Szenarien eingesetzt, wie z. B. zum Speichern von Konfigurationsinformationen, zur Kommunikation zwischen Prozessen und zur Definition von systemweiten Einstellungen. Das Verständnis, wie man mit Umgebungsvariablen arbeitet, ist eine essentielle Fähigkeit für jeden Linux-Benutzer oder Systemadministrator.

Dieses Lab wird Sie durch die Grundlagen des Setzens von Variablen, des Exportierens, um sie für Kindprozesse verfügbar zu machen, und des Verwenden in Bash-Skripten führen. Sie werden lernen, wie diese Variablen eingesetzt werden können, um dynamischere und konfigurierbarere Anwendungen zu erstellen.

Grundlegende Variablen in Linux verstehen

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

In Linux werden Variablen verwendet, um Daten zu speichern, auf die von Befehlen und Skripten verwiesen und die von ihnen manipuliert werden können. Eine Variable ist einfach ein Name, der einen Wert repräsentiert.

Beginnen wir damit, eine einfache Variable in Ihrer Shell zu erstellen:

name="LinuxLearner"

Dieser Befehl erstellt eine Variable namens name und weist ihr den Wert "LinuxLearner" zu. Beachten Sie, dass es beim Zuweisen von Werten zu Variablen keine Leerzeichen um das Gleichheitszeichen geben darf.

Um den Wert einer Variable anzuzeigen, verwenden Sie den echo-Befehl mit dem Variablennamen, der von einem Dollarzeichen ($) vorangestellt wird:

echo $name

Sie sollten die folgende Ausgabe sehen:

LinuxLearner

Sie können auch Variablen innerhalb von Zeichenketten verwenden:

echo "Hello, $name!"

Ausgabe:

Hello, LinuxLearner!

Nun erstellen Sie eine weitere Variable, um Ihre Lieblingsfarbe zu speichern:

color="blue"

Und 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 "Shell-Variablen" oder "lokale Variablen" genannt. Sie sind nur in der aktuellen Shell-Sitzung verfügbar. Im nächsten Schritt werden wir lernen, wie man Variablen mit dem export-Befehl für andere Prozesse verfügbar macht.

Exportieren von Variablen als Umgebungsvariablen

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

Zunächst verstehen wir den Unterschied:

Shell-Variable: Nur in der aktuellen Shell verfügbar
Umgebungsvariable: Für die aktuelle Shell und alle ihre Kindprozesse verfügbar

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

greeting="Welcome to Linux"

Nun erstellen wir 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 der Datei den folgenden Inhalt hinzu:

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

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

Machen Sie das Skript ausführbar:

chmod +x ~/project/test_var.sh

Nun führen Sie das Skript aus:

~/project/test_var.sh

Sie werden die folgende Ausgabe sehen:

The greeting is:

Beachten Sie, dass der Variablenwert nicht angezeigt wird, da Shell-Variablen nicht an Kindprozesse 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 so zu einer Umgebungsvariable gemacht, auf die andere Prozesse zugreifen können.

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

env

Dies wird eine Liste aller Umgebungsvariablen in Ihrer aktuellen Sitzung anzeigen.

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

echo $greeting

Nun erstellen und exportieren wir noch eine weitere Umgebungsvariable:

export USER_LEVEL="beginner"

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

echo $USER_LEVEL

Ausgabe:

beginner

Erstellen von Skripten, die Umgebungsvariablen nutzen

In diesem Schritt werden Sie lernen, wie Sie Skripts 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.

Zunächst erstellen wir 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 der Datei den folgenden Inhalt hinzu:

#!/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 Ctrl+O, dann Enter) und verlassen Sie nano (drücken Sie Ctrl+X).

Machen Sie das Skript ausführbar:

chmod +x ~/project/greet.sh

Nun führen Sie das Skript aus, ohne irgendwelche Umgebungsvariablen zu setzen:

~/project/greet.sh

Ausgabe:

Hello, Guest! Welcome to the Linux learning environment.

Das Skript hat die Standardwerte verwendet, da keine Umgebungsvariablen festgelegt wurden. Legen wir einige Umgebungsvariablen fest und führen das Skript erneut aus:

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 in Abhängigkeit von den von uns festgelegten Umgebungsvariablen geändert hat. Dies zeigt, wie Umgebungsvariablen verwendet werden können, um das Verhalten einer Anwendung zu konfigurieren, ohne den Code zu ändern.

Probieren wir es mit einer anderen Sprache aus:

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

Ausgabe:

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

Dieser Ansatz wird in der Softwarekonfiguration weit verbreitet eingesetzt, um Anwendungen flexibler und anpassungsfähiger an verschiedene Umgebungen zu machen.

Fortgeschrittene Nutzung und temporäre Umgebungsvariablen

In diesem Schritt werden Sie lernen, wie Sie Umgebungsvariablen für einen einzelnen Befehl festlegen, ohne die globale Umgebung zu ändern, und wie Sie fortgeschrittene Umgebungsvariablen-Nutzungen implementieren können.

Festlegen von Umgebungsvariablen für einen einzelnen Befehl

Manchmal möchten Sie eine Umgebungsvariable nur für einen einzelnen Befehl festlegen. Dies können Sie tun, indem Sie den Befehl mit der Zuweisung der Umgebungsvariablen voranstellen:

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

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

echo $LANGUAGE

Ausgabe:

French

Das liegt daran, dass die Umgebungsvariable nur für die Dauer des Befehls festgelegt wurde.

Umgebungsvariablen in einem realen Szenario

Erstellen wir ein praktischeres Beispiel - 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 Ctrl+O, dann Enter) und verlassen Sie nano (drücken Sie Ctrl+X).

Machen Sie das Skript ausführbar:

chmod +x ~/project/app_config.sh

Nun führen Sie das Skript aus, ohne irgendwelche Umgebungsvariablen zu setzen:

~/project/app_config.sh

Sie sollten Warnungen über fehlende Konfigurationen sehen.

Nun legen Sie alle erforderlichen Umgebungsvariablen fest und führen 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 korrekt angezeigt sehen, ohne irgendwelche Warnungen.

Versuchen Sie, einen ungültigen Log-Level festzulegen:

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 Anwendungs-Konfiguration verwendet werden können, mit Validierung und Standardwerten.

Umgebungsvariablen dauerhaft machen

Bisher haben wir Umgebungsvariablen festgelegt, die nur für die aktuelle Terminal-Sitzung gültig sind. Sobald Sie das Terminal schließen oder sich abmelden, gehen diese Variablen verloren. In diesem Schritt lernen Sie, wie Sie Umgebungsvariablen so festlegen können, dass sie über Sitzungen hinweg persistent sind.

Speichern von Umgebungsvariablen in Konfigurationsdateien

Es gibt mehrere Dateien, in denen Sie Umgebungsvariablen festlegen können, um sie persistent 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 Anmelden geladen werden

Fügen wir einige Umgebungsvariablen Ihrer Benutzershell-Konfigurationsdatei hinzu. Da in dieser Lab-Umgebung ZSH verwendet wird, bearbeiten wir die Datei ~/.zshrc:

nano ~/.zshrc

Scrollen Sie ans 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 Ctrl+O, dann Enter) und verlassen Sie nano (drücken Sie Ctrl+X).

Um diese Änderungen in Ihrer aktuellen Sitzung anzuwenden, müssen Sie die Datei "sourcen":

source ~/.zshrc

Prüfen Sie nun, ob die Variablen festgelegt 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 jedes Mal verfügbar, wenn Sie eine neue Shell-Sitzung starten.

Erstellen einer eigenen Datei für Umgebungsvariablen

Eine gute Praxis für die Verwaltung von Umgebungsvariablen ist es, eine separate Datei speziell für sie zu erstellen, insbesondere für projekt-spezifische Variablen. Dies erleichtert die Verwaltung und das Teilen 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 Ctrl+O, dann Enter) und verlassen Sie nano (drücken Sie Ctrl+X).

Um diese Variablen in Ihre aktuelle Sitzung zu laden, "sourcen" Sie die Datei:

source ~/project/.env

Prüfen Sie nun, ob die Variablen festgelegt sind:

echo $PROJECT_NAME
echo $PROJECT_VERSION
echo $DEBUG_MODE

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

Erstellen eines Skripts zum Laden von Umgebungsvariablen

Schließlich erstellen wir 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 Ctrl+O, dann Enter) und verlassen Sie nano (drücken Sie Ctrl+X).

Machen Sie das Skript ausführbar:

chmod +x ~/project/load_env.sh

Löschen Sie nun die zuvor festgelegten Variablen 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 ist.

Dieser Ansatz wird in Entwicklungsumgebungen häufig verwendet, um projekt-spezifische Umgebungsvariablen zu verwalten.

Zusammenfassung

In diesem Lab haben Sie die wesentlichen Konzepte zum Umgang mit Umgebungsvariablen in Linux gelernt:

Grundlegende Variablen: Sie haben gelernt, wie Sie Shell-Variablen in der aktuellen Sitzung erstellen und verwenden.
Umgebungsvariablen: Sie haben entdeckt, wie Sie den Befehl export verwenden können, um Shell-Variablen in Umgebungsvariablen umzuwandeln, auf die von Kindprozessen zugegriffen werden kann.
Verwendung von Variablen in Skripten: Sie haben Skripts erstellt, die Umgebungsvariablen lesen und verwenden, um ihr Verhalten anzupassen, ohne den Code zu ändern.
Fortgeschrittene Nutzung: Sie haben fortgeschrittene Techniken wie das Festlegen von Variablen für einen einzelnen Befehl und die Validierung von Variablenwerten in Skripten untersucht.
Persistenten Variablen: Sie haben gelernt, wie Sie Umgebungsvariablen persistent machen können, indem Sie sie in Konfigurationsdateien hinzufügen und Hilfsskripte erstellen, um sie zu laden.

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

Durch das Beherrschen von Umgebungsvariablen haben Sie eine wichtige Fähigkeit erworben, die Ihnen auf Ihrem Linux-Weg, von persönlichen Projekten bis hin zur Unternehmenssystemadministration, gut dienen wird.