Exportation de variables Linux

Introduction

Les variables d'environnement jouent un rôle crucial dans les systèmes d'exploitation Linux. Ce sont des valeurs dynamiques qui influencent les processus en cours d'exécution sur le système. Dans ce labo (LabEx), nous allons explorer comment utiliser la commande export sous Linux pour créer et gérer les variables d'environnement.

Les variables d'environnement sont utilisées dans de nombreux scénarios, tels que le stockage d'informations de configuration, la communication entre les processus et la définition de paramètres système. Comprendre comment manipuler les variables d'environnement est une compétence essentielle pour tout utilisateur Linux ou administrateur système.

Ce labo (LabEx) vous guidera à travers les bases de la définition de variables, de leur exportation pour les rendre disponibles aux processus enfants et de leur utilisation dans les scripts bash. Vous apprendrez comment ces variables peuvent être utilisées pour créer des applications plus dynamiques et configurables.

Comprendre les variables de base sous Linux

Dans cette étape, vous allez apprendre les bases de la création et de l'utilisation de variables dans un environnement de shell Linux.

Sous Linux, les variables sont utilisées pour stocker des données qui peuvent être référencées et manipulées par des commandes et des scripts. Une variable n'est simplement qu'un nom qui représente une valeur.

Commençons par créer une variable simple dans votre shell :

name="LinuxLearner"

Cette commande crée une variable appelée name et lui assigne la valeur "LinuxLearner". Notez qu'il ne devrait pas y avoir d'espaces autour du signe égal lors de l'affectation de valeurs aux variables.

Pour afficher la valeur d'une variable, vous utilisez la commande echo avec le nom de la variable précédé d'un signe dollar ($) :

echo $name

Vous devriez voir le résultat suivant :

LinuxLearner

Vous pouvez également utiliser des variables dans des chaînes de caractères :

echo "Hello, $name!"

Résultat :

Hello, LinuxLearner!

Maintenant, créez une autre variable pour stocker votre couleur préférée :

color="blue"

Et affichez un message en utilisant les deux variables :

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

Résultat :

Hello LinuxLearner, I see your favorite color is blue.

Les variables que vous avez créées sont appelées "variables de shell" ou "variables locales". Elles ne sont disponibles que dans la session de shell actuelle. Dans l'étape suivante, nous apprendrons comment rendre les variables disponibles pour d'autres processus en utilisant la commande export.

Exportation de variables en tant que variables d'environnement

Dans l'étape précédente, vous avez créé des variables de shell qui ne sont disponibles que dans votre session de shell actuelle. Dans cette étape, vous allez apprendre à utiliser la commande export pour convertir une variable de shell en une variable d'environnement qui sera disponible pour les processus enfants.

Commençons par comprendre la différence :

Variable de shell : Disponible uniquement dans le shell actuel
Variable d'environnement : Disponible pour le shell actuel et tous ses processus enfants

Pour illustrer cela, créons une nouvelle variable de shell :

greeting="Welcome to Linux"

Maintenant, créons un nouveau script de shell qui tente d'accéder à cette variable. Ouvrez un éditeur de texte et créez un fichier appelé test_var.sh dans le répertoire ~/project :

cd ~/project
nano test_var.sh

Ajoutez le contenu suivant au fichier :

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

Enregistrez le fichier (appuyez sur Ctrl+O, puis Entrée) et quittez nano (appuyez sur Ctrl+X).

Rendez le script exécutable :

chmod +x ~/project/test_var.sh

Maintenant, exécutez le script :

~/project/test_var.sh

Vous verrez le résultat suivant :

The greeting is:

Notez que la valeur de la variable n'est pas affichée car les variables de shell ne sont pas transmises aux processus enfants.

Pour rendre cette variable disponible pour le script, vous devez l'exporter :

export greeting="Welcome to Linux"

Maintenant, exécutez le script à nouveau :

~/project/test_var.sh

Cette fois, vous devriez voir :

The greeting is: Welcome to Linux

Félicitations ! Vous avez exporté avec succès une variable, la rendant ainsi une variable d'environnement accessible par d'autres processus.

Vous pouvez vérifier toutes les variables d'environnement actuelles en utilisant la commande env :

env

Cela affichera une liste de toutes les variables d'environnement de votre session actuelle.

Vous pouvez également vérifier une variable d'environnement spécifique avec la commande echo :

echo $greeting

Maintenant, créons et exportons une autre variable d'environnement :

export USER_LEVEL="beginner"

Exécutez la commande suivante pour vérifier qu'elle a été définie :

echo $USER_LEVEL

Résultat :

beginner

Création de scripts utilisant des variables d'environnement

Dans cette étape, vous allez apprendre à créer et exécuter des scripts qui utilisent des variables d'environnement pour la configuration. C'est une pratique courante dans le développement logiciel pour rendre les applications plus flexibles et configurables sans modifier le code.

Tout d'abord, créons un script qui utilise des variables d'environnement pour personnaliser sa sortie. Créez un nouveau fichier appelé greet.sh dans le répertoire ~/project :

cd ~/project
nano greet.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash
## Ce script démontre l'utilisation de variables d'environnement

## Valeurs par défaut si les variables d'environnement ne sont pas définies
DEFAULT_NAME="Guest"
DEFAULT_LANGUAGE="English"

## Utilisez les variables d'environnement ou les valeurs par défaut
USER_NAME=${USER_NAME:-$DEFAULT_NAME}
LANGUAGE=${LANGUAGE:-$DEFAULT_LANGUAGE}

## Salutation en fonction de la langue
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

Enregistrez le fichier (appuyez sur Ctrl+O, puis Entrée) et quittez nano (appuyez sur Ctrl+X).

Rendez le script exécutable :

chmod +x ~/project/greet.sh

Maintenant, exécutez le script sans définir de variables d'environnement :

~/project/greet.sh

Résultat :

Hello, Guest! Welcome to the Linux learning environment.

Le script a utilisé les valeurs par défaut car aucune variable d'environnement n'a été définie. Définissons quelques variables d'environnement et exécutons le script à nouveau :

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

Maintenant, exécutez le script à nouveau :

~/project/greet.sh

Résultat :

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

Notez comment la sortie du script a changé en fonction des variables d'environnement que nous avons définies. Cela démontre comment les variables d'environnement peuvent être utilisées pour configurer le comportement d'une application sans modifier le code.

Essayons avec une autre langue :

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

Résultat :

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

Cette approche est largement utilisée dans la configuration logicielle pour rendre les applications plus flexibles et adaptables à différents environnements.

Utilisation avancée et variables d'environnement temporaires

Dans cette étape, vous allez apprendre à définir des variables d'environnement pour une seule commande sans modifier l'environnement global, et à mettre en œuvre des utilisations plus avancées des variables d'environnement.

Définition de variables d'environnement pour une seule commande

Parfois, vous ne voulez définir une variable d'environnement que pour une seule commande. Vous pouvez le faire en préfixant la commande par les affectations de variables d'environnement :

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

Notez que le script s'exécute avec la configuration de langue espagnole, mais que la variable d'environnement globale n'a pas changé :

echo $LANGUAGE

Résultat :

French

Cela s'explique par le fait que la variable d'environnement n'a été définie que pour la durée de la commande.

Variables d'environnement dans un scénario du monde réel

Créons un exemple plus pratique - un script de configuration pour une application hypothétique. Créez un nouveau fichier appelé app_config.sh :

cd ~/project
nano app_config.sh

Ajoutez le contenu suivant :

#!/bin/bash
## Script de configuration de l'application

## Afficher la configuration actuelle
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 "--------------------------------"

## Vérifier si les configurations requises sont définies
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

## Valider le niveau de journalisation
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."

Enregistrez le fichier (appuyez sur Ctrl+O, puis Entrée) et quittez nano (appuyez sur Ctrl+X).

Rendez le script exécutable :

chmod +x ~/project/app_config.sh

Maintenant, exécutez le script sans définir de variables d'environnement :

~/project/app_config.sh

Vous devriez voir des avertissements concernant les configurations manquantes.

Maintenant, définissez toutes les variables d'environnement requises et exécutez le script à nouveau :

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

Vous devriez voir toutes les valeurs de configuration correctement affichées sans aucun avertissement.

Essayez de définir un niveau de journalisation invalide :

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

Le script devrait afficher un message d'erreur pour le niveau de journalisation invalide.

Cet exemple démontre comment les variables d'environnement peuvent être utilisées pour la configuration d'une application, avec validation et valeurs par défaut.

Rendre les variables d'environnement persistantes

Jusqu'à présent, nous avons défini des variables d'environnement qui ne durent que pour la session de terminal actuelle. Une fois que vous fermez votre terminal ou que vous vous déconnectez, ces variables sont perdues. Dans cette étape, vous allez apprendre à rendre les variables d'environnement persistantes d'une session à l'autre.

Stockage des variables d'environnement dans des fichiers de configuration

Il existe plusieurs fichiers où vous pouvez définir des variables d'environnement pour les rendre persistantes :

~/.bashrc ou ~/.zshrc : Pour les variables spécifiques à un utilisateur
/etc/environment : Pour les variables système
/etc/profile ou les fichiers dans /etc/profile.d/ : Pour les variables système chargées à la connexion

Ajoutons quelques variables d'environnement au fichier de configuration du shell de votre utilisateur. Comme cet environnement de laboratoire utilise ZSH, nous allons éditer le fichier ~/.zshrc :

nano ~/.zshrc

Faites défiler jusqu'au bas du fichier et ajoutez les lignes suivantes :

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

Enregistrez le fichier (appuyez sur Ctrl+O, puis Entrée) et quittez nano (appuyez sur Ctrl+X).

Pour appliquer ces modifications à votre session actuelle, vous devez charger le fichier :

source ~/.zshrc

Maintenant, vérifiez si les variables sont définies :

echo $EDITOR
echo $CUSTOM_PATH
echo $GREETING

Vous devriez voir les valeurs que vous avez définies dans le fichier .zshrc.

Ces variables d'environnement seront désormais disponibles chaque fois que vous démarrez une nouvelle session de shell.

Création d'un fichier de variables d'environnement personnalisé

Une bonne pratique pour gérer les variables d'environnement consiste à créer un fichier séparé pour elles, en particulier pour les variables spécifiques à un projet. Cela facilite la gestion et le partage des configurations.

Créons un fichier appelé .env dans votre répertoire de projet :

cd ~/project
nano .env

Ajoutez le contenu suivant :

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

Enregistrez le fichier (appuyez sur Ctrl+O, puis Entrée) et quittez nano (appuyez sur Ctrl+X).

Pour charger ces variables dans votre session actuelle, chargez le fichier :

source ~/project/.env

Maintenant, vérifiez si les variables sont définies :

echo $PROJECT_NAME
echo $PROJECT_VERSION
echo $DEBUG_MODE

Vous devriez voir les valeurs du fichier .env.

Création d'un script pour charger les variables d'environnement

Enfin, créons un script qui charge les variables d'environnement à partir d'un fichier. C'est un modèle courant dans les environnements de développement :

cd ~/project
nano load_env.sh

Ajoutez le contenu suivant :

#!/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

Enregistrez le fichier (appuyez sur Ctrl+O, puis Entrée) et quittez nano (appuyez sur Ctrl+X).

Rendez le script exécutable :

chmod +x ~/project/load_env.sh

Maintenant, supprimez les variables que nous avons précédemment définies, puis exécutez le script pour les charger à nouveau :

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"

Le script lit le fichier .env et exporte chaque variable définie avec le mot-clé export.

Cette approche est couramment utilisée dans les environnements de développement pour gérer les variables d'environnement spécifiques à un projet.

Résumé

Dans ce laboratoire, vous avez appris les concepts essentiels de l'utilisation des variables d'environnement sous Linux :

Variables de base : Vous avez appris à créer et utiliser des variables de shell dans la session actuelle.
Variables d'environnement : Vous avez découvert comment utiliser la commande export pour convertir des variables de shell en variables d'environnement accessibles par les processus enfants.
Utilisation de variables dans les scripts : Vous avez créé des scripts qui lisent et utilisent des variables d'environnement pour personnaliser leur comportement sans modifier le code.
Utilisation avancée : Vous avez exploré des techniques avancées telles que la définition de variables pour une seule commande et la validation des valeurs de variables dans les scripts.
Variables persistantes : Vous avez appris à rendre les variables d'environnement persistantes en les ajoutant à des fichiers de configuration et en créant des scripts utilitaires pour les charger.

Les variables d'environnement sont une fonctionnalité puissante sous Linux qui vous permet de configurer des applications, de partager des données entre les processus et de personnaliser votre environnement. Elles sont largement utilisées dans le développement logiciel, l'administration système et le déploiement d'applications.

En maîtrisant les variables d'environnement, vous avez acquis une compétence importante qui vous sera utile tout au long de votre parcours Linux, des projets personnels à l'administration système d'entreprise.