Exécution de scripts Linux

Introduction

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

Au cours de ce laboratoire, vous apprendrez :

• Comment créer et exécuter des scripts en utilisant la commande source
• Comment passer des paramètres aux scripts lors de l'utilisation de source
• En quoi la commande source diffère de l'exécution normale d'un script
• 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 programmation efficace des scripts shell Linux et la gestion de l'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 de shell actuel. Cela nous aidera à comprendre en quoi source diffère de l'exécution normale d'un script.

Lorsque vous exécutez un script normalement (en utilisant ./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 lorsque le script se termine. Cependant, lorsque vous utilisez la commande source (ou son raccourci .), les commandes du script s'exécutent dans votre environnement de shell actuel, permettant aux variables et aux fonctions de persister après la fin de l'exécution du script.

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

1. Accédez au répertoire du projet

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

cd ~/project

2. Créez un fichier de script simple

Créez un nouveau fichier nommé variables.sh en utilisant l'éditeur nano :

nano variables.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash
## Ce script définit une variable d'environnement
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. Rendez le script exécutable

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

chmod +x variables.sh

4. Exécutez le script normalement

Tout d'abord, exécutons le script de la 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

Il est probable que vous ne voyiez rien, ou une ligne vide. Cela est dû au fait 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écutez 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 - ci, 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. Utilisation de la notation abrégée

Vous pouvez également utiliser la notation abrégée (.) pour la commande source :

. variables.sh

Cela produira le même résultat que l'utilisation de source variables.sh.

Utilisation de 'source' avec des paramètres

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

Tout comme lors de l'exécution normale d'un script, vous pouvez passer des arguments à un script lorsque vous utilisez la commande source. À l'intérieur du script, ces arguments sont accessibles via les paramètres positionnels standard ($1, $2, etc.), tout comme s'il était exécuté directement.

1. Création d'un script qui accepte 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
## Ce script accepte un paramètre de nom et définit une variable de salutation

## Vérifie si un paramètre a été fourni
if [ -z "$1" ]; then
  NAME="Guest"
else
  NAME="$1"
fi

## Définit la variable d'environnement de salutation
export GREETING="Hello, $NAME!"
echo "$GREETING"

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

2. Rendez le script exécutable

chmod +x greeting.sh

3. Exécutez le script avec source en passant un paramètre

Exécutons le script avec source et passons un paramètre de nom :

source greeting.sh "Alice"

Vous devriez voir la sortie suivante :

Hello, Alice!

Maintenant, vérifiez si la variable GREETING est définie dans votre shell actuel :

echo $GREETING

Vous devriez voir :

Hello, Alice!

4. Exécutez le script avec source en passant un autre paramètre

Essayez d'exécuter le script avec source en passant un autre nom :

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écutez le script avec source sans paramètres

Vous pouvez également exécuter le script avec source 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 une dernière fois la variable GREETING :

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 pour l'environnement de développement

Dans cette étape, nous allons créer un exemple plus pratique : un script qui configure un environnement de développement avec plusieurs variables. C'est 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
## Script de configuration de l'environnement de développement

## Paramètres de connexion à la base de données
export DB_HOST="localhost"
export DB_PORT="5432"
export DB_USER="dev_user"
export DB_PASSWORD="dev_password"
export DB_NAME="dev_database"

## Paramètres de l'API
export API_URL="http://localhost:3000/api"
export API_KEY="dev_api_key_123"

## Chemins de l'application
export APP_ROOT="/home/labex/project/app"
export LOG_DIR="/home/labex/project/logs"

## Création des répertoires s'ils n'existent pas
mkdir -p $APP_ROOT
mkdir -p $LOG_DIR

## Affichage du message de confirmation
echo "Environnement de développement configuré avec les paramètres suivants :"
echo "-----------------------------------------------------------"
echo "Base de données : $DB_USER@$DB_HOST:$DB_PORT/$DB_NAME"
echo "URL de l'API : $API_URL"
echo "Racine de l'application : $APP_ROOT"
echo "Répertoire des journaux : $LOG_DIR"
echo "-----------------------------------------------------------"
echo "L'environnement est prêt pour le développement !"

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, exécutons le script avec source pour configurer notre environnement de développement :

source dev_env.sh

Vous devriez voir une sortie similaire à :

Environnement de développement configuré avec les paramètres suivants :
-----------------------------------------------------------
Base de données : dev_user@localhost:5432/dev_database
URL de l'API : http://localhost:3000/api
Racine de l'application : /home/labex/project/app
Répertoire des journaux : /home/labex/project/logs
-----------------------------------------------------------
L'environnement est prêt pour le développement !

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

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

echo "Chaîne de connexion à la base de données : $DB_USER:$DB_PASSWORD@$DB_HOST:$DB_PORT/$DB_NAME"

Sortie :

Chaîne de connexion à la base de données : dev_user:dev_password@localhost:5432/dev_database

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

echo "Paramètres de l'API : $API_URL avec la clé $API_KEY"

Sortie :

Paramètres de l'API : http://localhost:3000/api avec la clé dev_api_key_123

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

Vérifions 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 indiquant que les deux répertoires existent.

Cet exemple démontre comment vous pouvez 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 du shell actuel. Voici un récapitulatif de ce que vous avez accompli :

1. 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 normale d'un script, car elle permet aux variables et aux fonctions définies dans le script de persister dans votre session de shell actuelle.

2. Passage de paramètres à des scripts exécutés avec source : Vous avez exploré comment rendre les scripts plus flexibles en leur passant des paramètres lors de l'utilisation de la commande source, et comment traiter ces paramètres à l'intérieur du script.

3. 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 est un cas d'utilisation courant de la commande source dans le monde réel.

La commande source est un outil puissant dans la programmation de scripts sous Linux qui vous permet de :

• Définir des variables d'environnement qui persistent tout au long de votre session de shell
• Définir des fonctions qui peuvent être utilisées plus tard 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 tous ceux qui travaillent avec des systèmes Linux, en particulier pour les développeurs, les administrateurs systèmes et les ingénieurs DevOps. En maîtrisant la commande source, vous pouvez créer des scripts plus efficaces et organisés pour gérer votre environnement Linux.