Exportation de variables sous 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 laboratoire, nous explorerons comment utiliser la commande export sous Linux pour créer et gérer des 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 processus et la définition de paramètres à l'échelle du système. Comprendre comment manipuler les variables d'environnement est une compétence essentielle pour tout utilisateur ou administrateur système Linux.

Ce laboratoire vous guidera à travers les bases de la définition de variables, leur exportation pour les rendre accessibles aux processus enfants, et leur utilisation dans des 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 apprendrez les bases de la création et de l'utilisation de variables dans un environnement 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 est simplement 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 doit y avoir aucun espace autour du signe égal lors de l'assignation de valeurs aux variables.

Pour afficher la valeur d'une variable, utilisez la commande echo suivie du 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 au sein de 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 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.

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

Exporter des variables en tant que variables d'environnement

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

Comprenons d'abord la différence :

Variable 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 shell :

greeting="Welcome to Linux"

Maintenant, créons un nouveau script shell qui tente d'accéder à cette variable. Ouvrez un éditeur de texte et créez un fichier nommé 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 :

The greeting is:

Notez que la valeur de la variable n'est pas affichée car les variables 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"

Exécutez à nouveau le script :

~/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, en faisant 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 dans 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 bien été définie :

echo $USER_LEVEL

Résultat :

beginner

Créer des scripts utilisant des variables d'environnement

Dans cette étape, vous apprendrez à 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 nommé greet.sh dans le répertoire ~/project :

cd ~/project
nano greet.sh

Ajoutez le contenu suivant au fichier :

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

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 puisqu'aucune variable d'environnement n'a été définie. Définissons quelques variables d'environnement et exécutons à nouveau le script :

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

Exécutez à nouveau le script :

~/project/greet.sh

Résultat :

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

Remarquez 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 apprendrez à définir des variables d'environnement pour une seule commande sans modifier l'environnement global, et comment mettre en œuvre une utilisation plus avancée des variables d'environnement.

Définir des variables d'environnement pour une seule commande

Parfois, vous souhaitez définir une variable d'environnement uniquement pour une seule commande. Vous pouvez le faire en faisant précéder la commande par les assignations de variables d'environnement :

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

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

echo $LANGUAGE

Résultat :

French

C'est parce 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 réel

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

cd ~/project
nano app_config.sh

Ajoutez le contenu suivant :

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

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 à nouveau le script :

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'applications, 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 le temps de 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 apprendrez à rendre les variables d'environnement persistantes entre les sessions.

Stocker les 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 à l'échelle du système.
/etc/profile ou les fichiers dans /etc/profile.d/ : Pour les variables à l'échelle du système chargées à la connexion.

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

nano ~/.zshrc

Allez à la fin 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 changements à votre session actuelle, vous devez sourcer 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émarrerez une nouvelle session shell.

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

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

Créons un fichier nommé .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, sourcez 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éer 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, annulez les variables que nous avons définies précédemment, 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 pour travailler avec les variables d'environnement sous Linux :

Variables de base : Vous avez appris à créer et utiliser des variables shell dans la session actuelle.
Variables d'environnement : Vous avez découvert comment utiliser la commande export pour convertir des variables shell en variables d'environnement accessibles par les processus enfants.
Utilisation des 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 comme 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 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 en entreprise.