Comprendre les Shebangs : Exécuter des scripts Bash et Python dans le terminal Linux

Si vous avez déjà écrit un script shell ou Python sur Linux et vous vous êtes demandé comment le système sait quel interpréteur utiliser — la réponse réside dans une minuscule mais puissante séquence de deux caractères en haut de votre fichier : le shebang (#!).

Que vous automatisiez des tâches de maintenance de serveur, gériez des déploiements dans un environnement VPS Hosting, ou écriviez des scripts utilitaires pour votre serveur web, comprendre comment fonctionnent les shebangs est une compétence fondamentale en Linux que tout sysadmin et développeur devrait maîtriser.

Ce guide couvre tout ce que vous devez savoir : ce que sont les shebangs, comment les utiliser dans les scripts Bash et Python, et les meilleures pratiques qui distinguent les scripts amateurs de l’automatisation prête pour la production.

Qu’est-ce qu’un Shebang (#!) ?

Un shebang (également écrit *sha-bang*, *hashbang*, ou *pound-bang*) est une séquence de caractères spéciaux placée sur la toute première ligne d’un fichier de script. Il indique au noyau Linux quel interpréteur doit être utilisé pour exécuter le reste du fichier.

La syntaxe est simple :

#!/path/to/interpreter

Lorsque vous exécutez un script, le système d’exploitation lit les deux premiers octets du fichier. S’il trouve #!, il transmet le fichier à l’interpréteur spécifié sur cette ligne. Sans shebang, le shell peut tenter d’exécuter le script en utilisant son propre interpréteur intégré — ce qui peut entraîner un comportement inattendu ou un échec pur et simple, surtout lors du mélange de langages.

Exemples de Shebang courants

Pourquoi /usr/bin/env est important

Vous verrez fréquemment les shebangs écrits de deux styles différents :

#!/bin/python3

par rapport à :

#!/usr/bin/env python3

La deuxième forme est presque toujours préférée. Voici pourquoi :

• Portabilité : L’emplacement de python3 peut varier selon les distributions Linux, macOS et les systèmes BSD. /usr/bin/env recherche le $PATH de l’utilisateur pour trouver le bon interpréteur, quel que soit l’endroit où il est installé.
• Environnements virtuels : Lors de l’utilisation d’environnements virtuels Python (venv), /usr/bin/env python3 résoudra correctement le binaire Python du virtualenv plutôt que celui du système.
• Pérennité : Si un interpréteur est mis à jour ou déplacé, les scripts utilisant env continuent à fonctionner sans modification.

La seule fois où vous devriez utiliser un chemin absolu codé en dur (par exemple, #!/bin/bash) est lorsque vous avez besoin de garantir spécifiquement qu’un binaire particulier est utilisé — par exemple, dans les scripts sensibles à la sécurité où la manipulation de $PATH pourrait être un risque.

Utiliser les Shebangs dans les scripts Bash : Étape par étape

Parcourons la création d’un script Bash complet et exécutable à partir de zéro.

Étape 1 : Ouvrir un terminal

Accédez à votre terminal directement ou connectez-vous via SSH à votre serveur Linux.

Étape 2 : Créer un nouveau fichier de script Bash

Utilisez un éditeur de texte tel que nano pour créer un nouveau fichier :

nano myscript.sh

Étape 3 : Ajouter le Shebang et le contenu du script

Tout en haut du fichier, ajoutez la ligne shebang, suivie de votre logique de script :

#!/bin/bash

# A simple greeting script
echo "Hello, World!"
echo "Current date and time: $(date)"
echo "Running as user: $(whoami)"

Étape 4 : Enregistrer et quitter

Dans nano, appuyez sur CTRL + X, puis Y, puis Enter pour enregistrer et fermer le fichier.

Étape 5 : Rendre le script exécutable

Par défaut, les fichiers nouvellement créés ne sont pas exécutables. Accordez la permission d’exécution en utilisant chmod :

chmod +x myscript.sh

Vous pouvez vérifier le changement de permission avec :

ls -l myscript.sh

Vous devriez voir une sortie similaire à :

-rwxr-xr-x 1 user user 112 Jun 10 14:32 myscript.sh

Étape 6 : Exécuter le script

Exécutez le script directement depuis le terminal :

./myscript.sh

Sortie attendue :

Hello, World!
Current date and time: Tue Jun 10 14:32:01 UTC 2025
Running as user: youruser

> Remarque : Le préfixe ./ indique au shell de rechercher le script dans le répertoire courant. Si votre répertoire de scripts est ajouté à $PATH, vous pouvez exécuter les scripts par nom seul.

Utiliser les Shebangs dans les scripts Python : Étape par étape

Les scripts Python suivent le même modèle, avec une différence clé dans la ligne shebang recommandée.

Étape 1 : Créer un nouveau fichier de script Python

nano myscript.py

Étape 2 : Ajouter le Shebang et le code Python

#!/usr/bin/env python3

# A simple Python script demonstrating shebang usage
import sys
import platform

print("Hello from Python!")
print(f"Python version: {sys.version}")
print(f"Platform: {platform.system()} {platform.release()}")

Étape 3 : Enregistrer, quitter et rendre exécutable

# Save and exit nano with CTRL+X, Y, Enter
chmod +x myscript.py

Étape 4 : Exécuter le script

./myscript.py

Sortie attendue :

Hello from Python!
Python version: 3.11.2 (main, Mar 13 2023, 12:18:29)
Platform: Linux 5.15.0-76-generic

Notez que vous n’avez pas besoin de préfixer la commande avec python3 — le shebang gère la sélection de l’interpréteur automatiquement.

Exemples pratiques du monde réel

Comprendre le shebang isolément est utile, mais le voir appliqué à des tâches administratives réelles rend sa valeur évidente.

Bash : Script de sauvegarde automatisée

#!/bin/bash

# Automated backup script for web files
BACKUP_DIR="/var/backups/webfiles"
SOURCE_DIR="/var/www/html"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
BACKUP_FILE="$BACKUP_DIR/backup_$TIMESTAMP.tar.gz"

mkdir -p "$BACKUP_DIR"
tar -czf "$BACKUP_FILE" "$SOURCE_DIR"

echo "Backup completed: $BACKUP_FILE"

Python : Script de vérification de la santé du système

#!/usr/bin/env python3

import shutil
import psutil

def check_disk_usage(path="/"):
    total, used, free = shutil.disk_usage(path)
    percent_used = (used / total) * 100
    print(f"Disk Usage ({path}): {percent_used:.1f}% used")
    if percent_used > 85:
        print("WARNING: Disk usage is critically high!")

def check_memory():
    mem = psutil.virtual_memory()
    print(f"Memory Usage: {mem.percent}% used")

check_disk_usage()
check_memory()

Ces types de scripts sont inestimables lors de la gestion d’infrastructure — que vous exécutiez un seul compte Shared Web Hosting ou orchestriez des charges de travail sur Dedicated Servers.

Comportement du Shebang : Ce qui se passe sous le capot

Lorsque vous exécutez un script avec un shebang, le noyau Linux effectue les étapes suivantes :

1. Lit la première ligne du fichier et identifie la séquence #!.
2. Analyse le chemin de l’interpréteur (et tous les arguments optionnels) de la ligne shebang.
3. Invoque l’interpréteur, en passant le fichier de script comme argument.

Par exemple, exécuter ./myscript.py est équivalent en interne à :

/usr/bin/env python3 ./myscript.py

C’est pourquoi le shebang doit toujours être sur la première ligne sans espace blanc précédent — même une seule ligne vide avant elle causera l’ignorance du shebang.

Que se passe-t-il sans Shebang ?

Si aucun shebang n’est présent, le comportement dépend de la façon dont le script est invoqué :

• S’il est exécuté en tant que ./script.py, le shell courant (par exemple, Bash) tente de l’interpréter, ce qui échouera pour le code Python.
• S’il est exécuté en tant que python3 script.py, le shebang est hors de propos — Python est explicitement spécifié.
• S’il est exécuté en tant que bash script.sh, à nouveau le shebang est contourné.

Le shebang n’a d’importance que lorsque le script est exécuté directement (c’est-à-dire en tant que ./script).

Techniques avancées de Shebang

Passer des arguments à l’interpréteur

Vous pouvez passer des drapeaux à l’interpréteur via la ligne shebang :

#!/bin/bash -e

Le drapeau -e fait que Bash se termine immédiatement si une commande échoue — une pratique courante de sécurité pour les scripts de production.

#!/usr/bin/env python3 -u

Le drapeau -u force la sortie non mise en tampon dans Python, utile pour la journalisation en temps réel.

> Attention : Certains systèmes ne supportent qu’un seul argument après le chemin de l’interpréteur dans la ligne shebang. Pour la transmission d’arguments complexes, il est préférable de définir les options dans le script lui-même (par exemple, set -euo pipefail dans Bash).

Utiliser env avec des versions spécifiques

#!/usr/bin/env python3.11

Cela cible une version Python spécifique, utile dans les environnements où plusieurs versions coexistent.

Scripts polyglottiques

Dans certains cas avancés, les développeurs écrivent des scripts qui sont valides dans plusieurs langages simultanément. Le shebang permet cela en contrôlant quel interpréteur s’exécute en premier. Bien que cette soit une technique de niche, elle démontre la flexibilité que le shebang offre.

Meilleures pratiques pour écrire des lignes Shebang

Suivre ces meilleures pratiques rendra vos scripts plus robustes, portables et maintenables — particulièrement important dans les environnements de serveurs de production.

1. Toujours utiliser le bon interpréteur

Faites correspondre le shebang au langage et à la version que votre script nécessite :

#!/bin/bash          # For Bash-specific syntax
#!/bin/sh            # For POSIX-compliant shell scripts (more portable)
#!/usr/bin/env python3  # For Python 3 scripts

Ne supposez jamais que /bin/sh et /bin/bash sont interchangeables — ils ne le sont pas. Bash supporte des fonctionnalités (tableaux, [[ ]], substitution de processus) que POSIX sh ne supporte pas.

2. Préférer /usr/bin/env pour la portabilité

Comme discuté précédemment, utiliser env rend les scripts portables sur différents systèmes et environnements virtuels Python. Utilisez les chemins codés en dur uniquement lorsque la sécurité ou la spécificité l’exigent.

3. Toujours définir les permissions d’exécution

Les scripts sans permissions d’exécution échoueront avec une erreur « Permission refusée » :

chmod +x script.sh
chmod +x script.py

Pour les scripts destinés à tous les utilisateurs du système :

chmod 755 script.sh

4. Organiser les scripts dans un répertoire dédié

Créez un répertoire ~/scripts ou ~/bin pour les scripts personnels et ajoutez-le à votre $PATH :

mkdir -p ~/bin
echo 'export PATH="$HOME/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

Après cela, tout script exécutable placé dans ~/bin peut être exécuté par nom depuis n’importe où.

5. Ajouter des commentaires significatifs

Documentez vos scripts avec des commentaires expliquant leur objectif, utilisation et toute dépendance :

#!/bin/bash
# Script: backup_web.sh
# Purpose: Creates timestamped backups of web root
# Usage: ./backup_web.sh
# Dependencies: tar, gzip
# Author: Your Name
# Last Modified: 2025-06-10

6. Utiliser les options set pour des scripts Bash plus sûrs

Pour les scripts Bash de production, ajoutez ces options de sécurité immédiatement après le shebang :

#!/bin/bash
set -euo pipefail

• -e : Quitter en cas d’erreur
• -u : Traiter les variables non définies comme des erreurs
• -o pipefail : Capturer les erreurs dans les commandes en pipeline

7. Tester les scripts avant de les déployer en production

Testez toujours les scripts dans un environnement de développement ou de staging avant de les exécuter sur des serveurs de production. Si vous avez besoin d’un environnement isolé pour les tests, un plan VPS Hosting offre un bac à sable abordable et jetable qui reflète les conditions de production.

Dépannage des problèmes courants de Shebang

Erreur « Permission refusée »

bash: ./myscript.sh: Permission denied

Solution : Le script manque de permission d’exécution. Exécutez chmod +x myscript.sh.

Erreur « Fichier ou répertoire introuvable »

bash: ./myscript.py: /usr/bin/env: bad interpreter: No such file or directory

Solution : L’interpréteur spécifié dans le shebang n’existe pas à ce chemin. Vérifiez avec which python3 ou which bash.

Le script s’exécute avec le mauvais interpréteur

Symptôme : Des erreurs de syntaxe Python apparaissent lors de l’exécution d’un fichier .sh, ou vice versa.

Solution : Assurez-vous que la ligne shebang est à la ligne 1 sans espace blanc précédent ou lignes vides, et qu’elle pointe vers le bon interpréteur.

Fins de ligne Windows (rn)

Si vous modifiez des scripts sous Windows et les transférez vers Linux, les fins de ligne de style Windows peuvent corrompre le shebang :

/bin/bash^M: bad interpreter

Solution : Convertissez les fins de ligne avec dos2unix :

dos2unix myscript.sh

Shebang dans le contexte de l’administration de serveur

Pour quiconque gère une infrastructure d’hébergement basée sur Linux, la ma