Exécution de Scripts Shell

Différentes méthodes permettent d'exécuter des scripts shell sous Linux. Voici les approches courantes avec des exemples illustratifs.

Méthodes d'exécution

# Méthode par chemin relatif (nécessite un changement de répertoire)
cd /tmp
./demo_script.sh

# Méthode par chemin absolu
/tmp/demo_script.sh

# Appel via la commande bash
bash /tmp/demo_script.sh

# Exécution dans le shell courant avec la commande source
. /tmp/demo_script.sh

Différences clés entre les méthodes

Les trois premières méthodes nécessitent que le script dispose des permissions d'exécution, sauf lorsqu'on utilise explicitement la commande bash. Ces approches lancent un sous-shell pour exécuter le contenu du script. Une fois le script terminé, le sous-shell se ferme et le contrôle retourne au shell parent.

La méthode utilisant le point (source) exécute le script directement dans le shell courant sans créer de sous-shell. Cela signifie que toute modification des variables d'environnement dans le script affecte immédiatement le shell courant.

Validation des comportements

Pour illustrer, considérons un script nommé demo_script.sh contenant une commande comme top. L'exécution via un sous-shell montre une structure de processus où top est enfant du bash, tandis que l'exécution avec source intègre directement la commande dans le shell courant.

# Contenu de demo_script.sh
top

# Sortie de pstree pour les premières méthodes (sous-shell)
init──sshd──bash──bash──top
        └──bash──pstree

# Sortie de pstree pour la méthode source (shell courant)
init──sshd──bash──top
        └──bash──pstree

Héritage des variables d'environnement

Pour démontrer la différence d'héritage, deux scripts sont utilisés : parent_script.sh et child_script.sh. Le script parent définit une variable et appelle le script enfant de différentes manières.

# Contenu de parent_script.sh
var_test='parent'
echo "Appel via sous-shell"
/tmp/child_script.sh
echo "Valeur de var_test : ${var_test}"
echo "Appel via source"
. /tmp/child_script.sh
echo "Valeur de var_test : ${var_test}"

# Contenu de child_script.sh
var_test='enfant'

# Résultat d'exécution
Appel via sous-shell
Valeur de var_test : parent
Appel via source
Valeur de var_test : enfant

Exécution en arrière-plan et processus dæmons

Pour qu'un programme survive à la fermeture du terminal, il doit être détaché en tant que processus dæmon. Lorsqu'un terminal est fermé via l'interface graphique (par exemple, en cliquant sur la croix), le processus bash parent est tué, entraînant la terminaison de tous ses enfants. En revanche, une déconnexion propre via exit ou ctrl-d permet à bash de détacher les processus en arrière-plan avant de quitter.

Pour garantir la pérennité, il est recommandé d'utiliser un script shell exécuté sans la méthode source. Ainsi, le processus en arrière-plan est adopté par le processus init, le détachant du terminal.

# Exemple de script pour lancer un programme en arrière-plan
# Contenu de run_demon.sh
./long_running_program &

# Exécution
./run_demon.sh

# Vérification avec pstree, où long_running_program est sous init
init──long_running_program
        └──sshd──bash──pstree