Exécution de scripts Linux

Introduction

Ce laboratoire se concentre sur la compréhension et l'utilisation de la commande source sous Linux, un outil puissant pour exécuter des scripts directement dans le shell actuel. Contrairement à l'exécution classique d'un script qui se déroule dans un sous-processus séparé, la commande source exécute les commandes d'un fichier dans l'environnement shell courant. Cela permet aux variables et aux fonctions définies dans le script de persister dans votre session active.

Tout au long de ce laboratoire, vous apprendrez :

Comment créer et exécuter des scripts à l'aide de la commande source
Comment transmettre des paramètres aux scripts lors de l'utilisation de source
En quoi la commande source diffère de l'exécution de script classique
Comment utiliser la commande source pour configurer des variables d'environnement

À la fin de ce laboratoire, vous serez à l'aise avec l'utilisation de la commande source pour une gestion efficace de vos scripts shell Linux et de votre environnement.

Création et exécution d'un script de base avec source

Dans cette étape, nous allons créer un fichier de script simple et utiliser la commande source pour l'exécuter dans notre environnement shell actuel. Cela nous aidera à comprendre la différence entre source et l'exécution de script classique.

Lorsque vous exécutez un script normalement (via ./script.sh), le shell crée un nouveau sous-processus pour exécuter le script. Toutes les variables ou fonctions définies dans ce script n'existent que dans ce sous-processus et disparaissent une fois le script terminé. Cependant, lorsque vous utilisez la commande source (ou son raccourci .), les commandes du script s'exécutent dans votre environnement shell actuel, permettant aux variables et aux fonctions de persister après la fin du script.

Créons un script de base pour illustrer ce concept :

1. Accéder au répertoire du projet

Tout d'abord, assurez-vous d'être dans le bon répertoire :

cd ~/project

2. Créer un fichier de script simple

Créez un nouveau fichier nommé variables.sh à l'aide de l'éditeur nano :

nano variables.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash
## This script sets an environment variable
export WEATHER="Sunny"
echo "The weather is now set to: $WEATHER"

Appuyez sur Ctrl+O pour enregistrer le fichier, puis sur Enter pour confirmer le nom du fichier, et enfin sur Ctrl+X pour quitter nano.

3. Rendre le script exécutable

Avant de pouvoir exécuter le script, nous devons le rendre exécutable :

chmod +x variables.sh

4. Exécuter le script normalement

Commençons par exécuter le script de manière traditionnelle :

./variables.sh

Vous devriez voir une sortie similaire à :

The weather is now set to: Sunny

Maintenant, vérifiez si la variable WEATHER existe dans votre shell actuel :

echo $WEATHER

Vous ne verrez probablement rien, ou une ligne vide. C'est parce que la variable n'a été définie que dans le sous-processus qui a exécuté le script, et non dans votre shell actuel.

5. Exécuter le script avec source

Maintenant, utilisons la commande source pour exécuter le script :

source variables.sh

Vous verrez la même sortie :

The weather is now set to: Sunny

Vérifiez à nouveau la variable WEATHER :

echo $WEATHER

Cette fois, vous devriez voir :

Sunny

La variable WEATHER existe maintenant dans votre shell actuel car vous avez utilisé la commande source pour exécuter le script.

6. Utiliser la notation raccourcie

Vous pouvez également utiliser le point (.) comme raccourci pour la commande source :

. ./variables.sh

Cela produira le même résultat que source variables.sh. Le préfixe ./ indique au shell de sourcer le script depuis le répertoire actuel.

Utilisation de source avec des paramètres

Dans cette étape, nous apprendrons à transmettre des paramètres à un script lors de l'utilisation de la commande source. C'est utile lorsque vous avez besoin de rendre vos scripts plus flexibles et réutilisables.

Tout comme pour l'exécution de script classique, vous pouvez transmettre des arguments à un script lors de l'utilisation de la commande source. À l'intérieur du script, ces arguments sont accessibles via les paramètres positionnels standard ($1, $2, etc.), exactement comme si vous exécutiez le script directement.

1. Création d'un script acceptant des paramètres

Créez un nouveau fichier appelé greeting.sh dans le répertoire ~/project :

cd ~/project
nano greeting.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash
## This script accepts a name parameter and sets a greeting variable

## Check if a parameter was provided
if [ -z "$1" ]; then
  NAME="Guest"
else
  NAME="$1"
fi

## Set the greeting environment variable
export GREETING="Hello, $NAME!"
echo "$GREETING"

Enregistrez et quittez nano en appuyant sur Ctrl+O, Enter, puis Ctrl+X.

2. Rendre le script exécutable

chmod +x greeting.sh

3. Exécuter le script avec un paramètre via source

Sourçons le script en transmettant un paramètre de nom :

source greeting.sh "Alice"

Vous devriez voir la sortie suivante :

Hello, Alice!

Vérifiez maintenant si la variable GREETING est définie dans votre shell actuel :

echo $GREETING

Vous devriez voir :

Hello, Alice!

4. Exécuter avec un paramètre différent

Essayez de sourcer à nouveau le script avec un nom différent :

source greeting.sh "Bob"

Sortie :

Hello, Bob!

Vérifiez à nouveau la variable GREETING :

echo $GREETING

Sortie :

Hello, Bob!

Remarquez comment la variable GREETING a été mise à jour avec la nouvelle valeur.

5. Exécuter sans paramètres

Vous pouvez également sourcer le script sans aucun paramètre :

source greeting.sh

Sortie :

Hello, Guest!

Le script utilise une valeur par défaut ("Guest") lorsqu'aucun paramètre n'est fourni.

Vérifiez la variable GREETING une dernière fois :

echo $GREETING

Sortie :

Hello, Guest!

Cela démontre comment vous pouvez rendre vos scripts adaptables en traitant différents paramètres d'entrée.

Création d'un script d'environnement de développement

Dans cette étape, nous allons créer un exemple plus concret : un script qui configure un environnement de développement avec plusieurs variables. Il s'agit d'un cas d'utilisation courant de la commande source dans des scénarios réels.

1. Création du script d'environnement de développement

Créez un nouveau fichier appelé dev_env.sh dans le répertoire ~/project :

cd ~/project
nano dev_env.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash
## Development environment setup script

## Database connection settings
export DB_HOST="localhost"
export DB_PORT="5432"
export DB_USER="dev_user"
export DB_PASSWORD="dev_password"
export DB_NAME="dev_database"

## API settings
export API_URL="http://localhost:3000/api"
export API_KEY="dev_api_key_123"

## Application paths
export APP_ROOT="/home/labex/project/app"
export LOG_DIR="/home/labex/project/logs"

## Create directories if they don't exist
mkdir -p $APP_ROOT
mkdir -p $LOG_DIR

## Display confirmation message
echo "Development environment configured with the following settings:"
echo "-----------------------------------------------------------"
echo "Database: $DB_USER@$DB_HOST:$DB_PORT/$DB_NAME"
echo "API URL: $API_URL"
echo "App Root: $APP_ROOT"
echo "Log Directory: $LOG_DIR"
echo "-----------------------------------------------------------"
echo "Environment is ready for development!"

Enregistrez et quittez nano en appuyant sur Ctrl+O, Enter, puis Ctrl+X.

2. Rendre le script exécutable

chmod +x dev_env.sh

3. Exécuter le script d'environnement de développement avec source

Maintenant, sourçons le script pour configurer notre environnement de développement :

source dev_env.sh

Vous devriez voir une sortie similaire à :

Development environment configured with the following settings:
-----------------------------------------------------------
Database: dev_user@localhost:5432/dev_database
API URL: http://localhost:3000/api
App Root: /home/labex/project/app
Log Directory: /home/labex/project/logs
-----------------------------------------------------------
Environment is ready for development!

4. Vérifier que les variables d'environnement sont définies

Vérifions certaines des variables d'environnement définies par le script :

echo "Database connection string: $DB_USER:$DB_PASSWORD@$DB_HOST:$DB_PORT/$DB_NAME"

Sortie :

Database connection string: dev_user:dev_password@localhost:5432/dev_database

Vérifiez les paramètres de l'API :

echo "API settings: $API_URL with key $API_KEY"

Sortie :

API settings: http://localhost:3000/api with key dev_api_key_123

5. Vérifier que les répertoires ont été créés

Vérifiez si les répertoires spécifiés dans le script ont été créés :

ls -la ~/project/app ~/project/logs

Vous devriez voir une sortie confirmant que les deux répertoires existent.

Cet exemple démontre comment utiliser la commande source pour configurer un environnement de développement complet avec plusieurs variables d'environnement et configurations. Cette approche est couramment utilisée dans les flux de travail de développement pour basculer entre différents environnements (développement, test, production, etc.).

Résumé

Dans ce laboratoire, vous avez appris à utiliser la commande source sous Linux pour exécuter des scripts dans l'environnement shell actuel. Voici un récapitulatif de ce que vous avez accompli :

Création et exécution de scripts de base avec source : Vous avez appris en quoi l'utilisation de source diffère de l'exécution de script classique, car elle permet aux variables et aux fonctions définies dans le script de persister dans votre session shell actuelle.
Transmission de paramètres aux scripts sourcés : Vous avez exploré comment rendre les scripts plus flexibles en leur transmettant des paramètres lors de l'utilisation de la commande source, et comment traiter ces paramètres au sein du script.
Configuration d'environnements de développement : Vous avez créé un script pratique qui configure un environnement de développement avec plusieurs variables d'environnement et configurations, ce qui constitue un cas d'utilisation réel courant pour la commande source.

La commande source est un outil puissant dans le scripting Linux qui vous permet de :

Définir des variables d'environnement qui persistent tout au long de votre session shell
Définir des fonctions pouvant être utilisées ultérieurement dans votre session
Créer des configurations modulaires réutilisables
Configurer rapidement et de manière cohérente des environnements complexes

Ces compétences sont fondamentales pour toute personne travaillant avec des systèmes Linux, en particulier pour les développeurs, les administrateurs système et les ingénieurs DevOps. En maîtrisant la commande source, vous pouvez créer des scripts plus efficaces et mieux organisés pour gérer votre environnement Linux.