Comment créer un script Bash avec un menu graphique et des interfaces interactives

Si vous utilisez quotidiennement GNU/Linux, il est inévitable que vous finissiez par créer des scripts bash pour automatiser des tâches : sauvegardes, nettoyage des fichiers temporaires, surveillance, installateurs personnalisés… Tout cela est formidable, mais dès que le script commence à prendre de l’ampleur, la même question se pose : comment le rendre plus convivial, avec un menu graphique ou interactif , et sans avoir à se souvenir de chaque paramètre ?

La bonne nouvelle, c'est que vous n'avez pas besoin d'être développeur GTK ou Qt pour y parvenir. Avec quelques outils légers comme dialog, whiptail ou zenity , vous pouvez créer des menus, des boîtes de dialogue, des listes et des barres de progression, aussi bien dans le terminal que dans un environnement graphique, sans quitter l'écosystème bash. Et si vous souhaitez aller plus loin, vous pouvez également intégrer bash à des interfaces plus puissantes, voire à des bots Telegram.

Qu'est-ce qu'un script bash et pourquoi est-il judicieux d'y ajouter un menu ?

Un script Bash est simplement un fichier texte contenant une liste d'instructions que le shell exécute séquentiellement. En quelques lignes seulement, vous pouvez automatiser des tâches simples (comme l'exécution répétée d'une même série de commandes ) ainsi que des utilitaires d'administration complexes avec des fonctions, des boucles et des structures de contrôle.

Pour que Linux le reconnaisse comme un exécutable bash, trois conditions de base doivent être remplies : ajouter le shebang correspondant sur la première ligne , lui accorder les permissions d’exécution et, éventuellement, lui donner une extension reconnaissable (généralement .sh est utilisé par commodité, bien que ce ne soit pas obligatoire).

Un en-tête de script typique ressemblerait à ceci : #! / Bin / bashEt si vous souhaitez déboguer ligne par ligne, vous pouvez activer le mode de traçage avec #!/bin/bash-xIl vous suffit alors de faire un chmod +x nombre_del_script o chmod 755 nombre_del_script et ensuite vous pouvez l'exécuter avec ./nombre_del_script.

Un simple script « hello world » pourrait être :

#!/bin/bash
echo "Hola. Soy tu primer script Bash"

À partir de là, vous pouvez ajouter des variables, des conditions, des boucles et des fonctions pour en faire un petit outil. Le problème, c'est que, à mesure qu'il s'étoffe, demander à l'utilisateur de le gérer uniquement avec des paramètres ou en mémorisant des nombres dans le terminal devient vite fastidieux.

C’est pourquoi l’ajout d’un menu interactif ou graphique en surimpression est si judicieux : la logique reste dans bash, mais l’expérience utilisateur est grandement améliorée, notamment pour les personnes moins à l’aise avec la console.

Concepts Bash dont vous aurez besoin avant d'ajouter des menus

Pour éviter que vos menus (textuels ou graphiques) ne deviennent illisibles, il est essentiel de maîtriser les bases de Bash : paramètres, tableaux, structures de contrôle, opérateurs, redirections et fonctions. Nul besoin d'être un expert, mais il est indispensable de les connaître.

Concernant les paramètres, Bash propose plusieurs variables spéciales très utiles : `$#` indique le nombre d'arguments passés au script, `$0` contient le nom du script , `$1…$9` sont les neuf premiers paramètres , et `${N}` permet d'accéder à n'importe quelle position. Pour les gérer en masse, vous disposez de `$*` et `$@` , et `$$` renvoie l'identifiant du processus (PID) du script. Le code de sortie de la dernière commande est stocké dans `$ ?`.

Une commande clé dans les scripts qui acceptent de nombreux arguments est décalageCela vous permet de décaler les paramètres d'une position vers l'arrière, afin de pouvoir traiter des options telles que : --nombre o --apellido dans n'importe quel ordre, sans s'arracher les cheveux. C'est courant dans les scripts qui acceptent des options de type GNU et où l'on souhaite que l'utilisateur puisse les saisir dans l'ordre de son choix.

Les les variables En Bash, les variables ne sont pas typées : elles peuvent stocker du texte, des nombres, des tableaux, tout ce que vous voulez. Vous pouvez leur assigner des valeurs directement. VAR=texto ou les construire à partir de la sortie d'une commande utilisant VAR=$(comando) ou l'ancienne méthode avec les guillemets inversés. Attention au guillemets simples et doublesLes guillemets simples ne développent pas les variables, contrairement aux guillemets doubles.

Un autre pilier est le tableauxVous pouvez les déclarer avec ARRAY=(a b c)attribuer des éléments individuels avec ARRAY[0]=valor et accès avec ${ARRAY[n]}De plus, vous avez accès à des services publics tels que ${ARRAY[@]} pour tous les éléments, ${#ARRAY[@]} pour savoir combien il y en a ou ${!ARRAY[@]} pour obtenir les indices actifs, ce qui est très utile lorsque le tableau comporte des « lacunes ».

Enfin, le Structures de contrôle Les instructions classiques (if, case, for, while, until, select) vous permettent de prendre des décisions et de créer des menus basiques sans avoir encore besoin d'outils externes. select + case Il est particulièrement utile pour créer des menus de console très rapides.

Création de menus bash dans le terminal (sans interface graphique)

Avant de passer à un menu graphique complet, il est judicieux de maîtriser les menus interactifs textuels en utilisant uniquement bash. Ils sont légers, fonctionnent parfaitement via SSH et, bien conçus, sont très agréables à utiliser.

La méthode la plus directe consiste à afficher une liste d'options avec `echo` , à lire la sélection avec `read` , puis à utiliser une instruction `case` pour exécuter l'action correspondante. C'est le modèle classique des scripts de maintenance ou de sauvegarde comportant plusieurs tâches prédéfinies.

Imaginez que vous ayez un script qui effectue quatre types de sauvegarde avec 7z (tmp, Dropbox, Documents et Android Studio). Au lieu de tout exécuter en même temps, vous pouvez configurer un menus simples pour choisir la copie que vous souhaitez réaliser :

#!/bin/bash
FECHA=$(date +"%Y-%m-%d")

echo "[ Seleccione opción de Backup ]"
echo "1: tmp"
echo "2: dropbox"
echo "3: documents"
echo "4: android"

read n
case $n in
  1) 7z a -t7z /media/usuario/hddexterno/${FECHA}-tmp.7z \
         /home/usuario/tmp -mx9 -pContraseña ;;
  2) 7z a -t7z /media/usuario/hddexterno/${FECHA}-dropbox.7z \
         /home/usuario/Dropbox -mx9 -pContraseña ;;
  3) 7z a -t7z /media/usuario/hddexterno/${FECHA}-documents.7z \
         /home/usuario/Documentos -mx9 -pContraseña ;;
  4) 7z a -t7z /media/usuario/hddexterno/${FECHA}-android.7z \
         /home/usuario/AndroidStudio -mx9 -pContraseña ;;
  *) echo "Opción incorrecta" ;;
esac

Cela transforme le script d'une « boîte noire » en une interface en texte clair . Pour une présentation plus soignée, bash propose la commande `select` , qui génère une liste numérotée d'options et gère la sélection à votre place.

Un exemple légèrement plus avancé à l'aide select il pourrait être:

#!/bin/bash
FECHA=$(date +"%Y-%m-%d")
PS3="[ Seleccione opción de Backup ] "
options=("tmp" "dropbox" "documents" "android" "Salir")

select opt in "${options[@]}"; do
  case $opt in
    tmp)
      7z a -t7z /media/usuario/hddexterno/${FECHA}-tmp.7z \
         /home/usuario/tmp -mx9 -pContraseña ;;
    dropbox)
      7z a -t7z /media/usuario/hddexterno/${FECHA}-dropbox.7z \
         /home/usuario/Dropbox -mx9 -pContraseña ;;
    documents)
      7z a -t7z /media/usuario/hddexterno/${FECHA}-documents.7z \
         /home/usuario/Documentos -mx9 -pContraseña ;;
    android)
      7z a -t7z /media/usuario/hddexterno/${FECHA}-android.7z \
         /home/usuario/AndroidStudio -mx9 -pContraseña ;;
    Salir)
      break ;;
    *)
      echo "Opción incorrecta" ;;
  esac
done

Comme vous pouvez le constater, avec très peu de code, vous obtenez un menu répétable où l'utilisateur peut choisir plusieurs options successivement jusqu'à sélectionner « Quitter ». Ce modèle peut être réutilisé dans pratiquement n'importe quel script où vous souhaitez proposer plusieurs opérations groupées.

Dialogue et menu « whiptail » : menus « graphiques » en mode texte

Pour aller plus loin dans le terminal, des outils comme dialog et whiptail entrent en jeu . Ils fonctionnent toujours dans une console texte, mais permettent de créer des fenêtres, des menus avec curseur, des listes à cocher, des barres de progression , etc., le tout contrôlé par le script à l'aide d'arguments.

dialogue C'est un système bien connu dans l'univers GNU/Linux : de nombreux installateurs, comme celui de Slackware, sont construits à partir d'un ensemble de scripts Bash gérés par dialog. Grâce à lui, on peut créer aussi bien de simples messages d'information que des formulaires complexes. Sa syntaxe s'articule toujours autour d'une commande comme `/etc/bash`. dialog --opcion ... qui renvoie le résultat via la sortie standard ou via le code de sortie.

Un exemple classique de menu avec curseurs dans une boîte de dialogue serait :

respuesta=$(dialog --title "Ejemplo de menú" \
                  --stdout \
                  --menu "Opciones" 12 40 4 \
                  1 "Opción 1" \
                  2 "Opción 2" \
                  3 "Opción 3" \
                  4 "Opción 4")

echo "Has elegido: $respuesta"

Le choix –stdout Cela envoie le choix de l'utilisateur à la sortie standard, vous pouvez donc l'enregistrer directement dans une variable. $(...)Les chiffres 12 40 4 Elles indiquent la hauteur, la largeur et le nombre maximal d'éléments visibles dans le menu.

Outre le menu simple, la boîte de dialogue prend en charge les boîtes de message , les confirmations ( « oui »), les champs de saisie de texte, les listes à cocher, les listes à choix unique (boutons radio ) et les barres de progression, parmi de nombreux autres types d'éléments. Pour connaître l'ensemble des fonctionnalités prises en charge, consultez la page de manuel ou la documentation officielle.

whiptail est une alternative plus légère basée sur la bibliothèque newt. Elle propose un ensemble de boîtes de dialogue très similaires à dialog, avec une syntaxe presque identique, mais est parfois préférable car elle consomme moins de ressources ou est déjà disponible dans des environnements minimalistes.

Un menu créé avec whiptail ressemblerait à ceci :

#!/bin/bash
opcion=$(whiptail --title "Menú Principal" \
                  --menu "Seleccione una opción:" 15 50 4 \
                  "1" "Ver información del sistema" \
                  "2" "Mostrar uso del disco" \
                  "3" "Configurar red" \
                  "4" "Salir" 3>&1 1>&2 2>&3)

clear
case $opcion in
  1) echo "Mostrando información del sistema..." ;;
  2) echo "Mostrando uso del disco..." ;;
  3) echo "Configurando la red..." ;;
  4) echo "Saliendo..." ; exit 0 ;;
  *) echo "Opción no válida." ;;
esac

L'astuce de 3>&1 1>&2 2>&3 Il est souvent utilisé avec whiptail pour rediriger la sortie de sélection vers le descripteur approprié afin qu'elle puisse être capturée avec $(...)Même si cela peut paraître incompréhensible, en pratique, on le réutilise toujours de la même manière.

Dialogue et whiptail en détail : messages, listes et barres de progression

Une fois que tu as boîte de dialogue installée ou whiptail (sur Debian/Ubuntu avec un sudo apt-get install dialog o sudo apt-get install whiptailet dans RHEL/CentOS via yum (avec les packages correspondants), vous pouvez commencer à construire des interfaces de plus en plus conviviales.

Par exemple, un message simple avec dialogue est aussi simple que :

#!/bin/bash
dialog --title "Mensaje" \
       --msgbox "Hola, este es un cuadro de mensaje simple." 6 50

Si vous souhaitez un menu principal avec plusieurs actions, vous disposez d'un modèle typique comme celui-ci :

#!/bin/bash
opcion=$(dialog --title "Menú Principal" \
               --menu "Selecciona una opción:" 15 50 4 \
               1 "Opción 1" \
               2 "Opción 2" \
               3 "Opción 3" \
               4 "Salir" 3>&1 1>&2 2>&3)

clear
echo "Has seleccionado la opción: $opcion"

Les listes à sélection multiple Ils sont construits avec --checklistUn exemple typique serait un programme d'installation qui vous permet de choisir les paquets à installer :

#!/bin/bash
opciones=$(dialog --title "Selección de Paquetes" \
                 --checklist "Selecciona los paquetes que deseas instalar:" \
                 15 50 5 \
                 "Apache" off \
                 "MySQL"  off \
                 "PHP"    off \
                 "Python" off \
                 "Java"   off 3>&1 1>&2 2>&3)

clear
echo "Paquetes seleccionados: $opciones"

Le mot « off » indique que la case est initialement décochée, tandis que dans Whiptail, on utilise généralement ON/OFF en majuscules. Le format de sortie est généralement une liste d'éléments sélectionnés, séparés par des espaces ou des guillemets, selon la configuration.

Pour afficher la progression d'une tâche longue, la boîte de dialogue propose l'option `--gauge` . Le principe est de lui envoyer des valeurs numériques (de 0 à 100) via l'entrée standard pendant que votre script effectue le travail.

#!/bin/bash
{ 
  for ((i = 0; i <= 100; i+=10)); do
    sleep 1
    echo $i
  done
} | dialog --title "Progreso" --gauge "Instalando..." 10 70 0

Whiptail propose une fonctionnalité quasi identique via son option `--gauge` . Dans les deux cas, la logique est la même : une boucle met à jour le pourcentage et l’affiche dans la barre de progression.

De véritables interfaces graphiques avec Zenity (GTK) pour vos scripts

Si vous travaillez dans un environnement serveur graphique (Gnome, KDE, etc.) et souhaitez aller plus loin, vous pouvez utiliser Zenity pour créer des boîtes de dialogue GTK directement depuis bash. Zenity est conçu précisément pour cela : donner une interface graphique à vos scripts sans avoir à développer une application complète.

L'installation sur Debian/Ubuntu est aussi simple que :

sudo apt-get install zenity

Dans les systèmes basés sur Red Hat, l'idée est la même, généralement avec sudo yum install zenity ou le paquet équivalent. Une fois installé, vous pouvez l'appeler depuis le terminal ou depuis votre script avec des commandes comme zenity --info ....

Zenity propose plusieurs types de boîtes de dialogue : information, avertissement, erreur, question, sélection de fichiers, formulaires, listes, barres de progression , etc. Par exemple, un simple message d’information :

zenity --info --text="Información"

Un avertissement ou une erreur :

zenity --warning --text="Advertencia"
zenity --error   --text="Error"

L'astuce consiste à enregistrer le chemin d'accès dans une variable en capturant la sortie de Zenity dans le script. Si vous souhaitez que l'utilisateur sélectionne un fichier et enregistre son chemin d'accès dans une variable, vous pouvez procéder comme suit :

file=$(zenity --file-selection)

À partir de ce moment, vous pouvez utiliser `$file` comme n'importe quel autre chemin saisi au clavier. C'est un excellent moyen de demander des paramètres sans avoir à saisir des chemins interminables dans le terminal.

Exemples avancés : notifications, barres de console et automatisation Web

Outre les menus, Bash fonctionne parfaitement avec de nombreux petits utilitaires permettant de créer des solutions assez élaborées sans quitter l'écosystème de la console. Voici quelques exemples pratiques qui s'intègrent bien aux interfaces à menus.

Pour interagir avec le web, vous pouvez utiliser des navigateurs de texte comme Lynx ou des gestionnaires de téléchargement comme wget . Un exemple concret : la vérification des nouveaux messages sur les forums d'un projet hébergé sur SourceForge. Le script télécharge la page avec Lynx, extrait les lignes contenant « Dernière action », les enregistre dans un fichier et les compare à la dernière exécution à l'aide de diff . Si des modifications sont constatées, vous savez qu'il y a du nouveau contenu à examiner.

Un autre exemple typique consiste à automatiser les compilations ou les tâches de développement. Par exemple, compiler de petits programmes OpenGL/GLUT pour Windows sous Linux à l'aide de MinGW et Wine avec une seule ligne de script, en générant automatiquement le nom de l'exécutable à partir du nom du fichier .cpp grâce à sed et aux substitutions de chaînes de caractères.

Les notifications de bureau Ils constituent également un excellent complément aux scripts qui s'exécutent « en arrière-plan » pendant que vous faites autre chose. notify-send (extrait de l'emballage) libnotify-bin (Dans de nombreuses distributions) permet d'afficher des notifications dans la barre des tâches, idéal pour informer les utilisateurs qu'une copie d'un DVD avec dd a pris fin, par exemple :

notify-send -t 4000 "Terminó!"

Si vous préférez des interfaces entièrement textuelles mais visuellement attrayantes, vous pouvez combiner plusieurs utilitaires tels que df, ls, bc, ps, xrandr ou tput pour afficher des barres de progression dans la console, des animations (comme une chute de neige avec des personnages), ou même des scripts qui calculent la résolution de l'écran et l'utilisent pour enregistrer des screencasts avec ffmpeg.

Bash avancé : redirections, pipes et gestion des erreurs

Derrière tout menu digne de ce nom se cache généralement une bonne gestion des entrées/sorties standard . Sous Linux, tout transite par trois descripteurs : stdin (0), stdout (1) et stderr (2). Selon la manière dont vous redirigez chacun d’eux, vous pouvez enregistrer les résultats dans des fichiers, masquer les erreurs, les combiner ou enchaîner les commandes à l’aide de tubes.

La redirection de base > envoie la sortie standard vers un fichier (en l'écrasant), tandis que >> Ajoutez-le à la fin. Si vous souhaitez séparer les résultats et les erreurs, vous disposez d'une syntaxe comme celle-ci : 1>fichero y 2>erroresVous pouvez également envoyer les erreurs au même endroit que la sortie avec 2>&1 ou vice et versa.

Une pratique courante consiste à générer une liste et à enregistrer silencieusement uniquement le résultat, en ignorant les erreurs en les redirigeant vers /dev/null . Par exemple :

ls -1 /tmp/Carpeta1 1>/tmp/lista_ficheros.txt 2>/dev/null

Les tuyaux (|Voici l'autre composant important. Ils permettent de transmettre la sortie d'une commande à l'entrée de la suivante, formant ainsi des chaînes très puissantes. Un exemple classique : trier une liste de fichiers avec sort ou calculer la résolution de l'écran avec xrandr | grep | awk enchaînés. Ce même mécanisme est utilisé pour alimenter les barres de progression dans les formulaires dialog/whiptail ou Zenity.

Quant à contrôle des erreursToutes les commandes renvoient un code de sortie accessible avec $?Les scripts bien écrits stockent généralement cette valeur dans une variable et la renvoient à la fin. exit, permettant au système ou à d'autres scripts de savoir si tout s'est bien passé (code 0) ou si quelque chose a échoué (toute valeur autre que 0).

Au sein des fonctions, l'équivalent de exit es retournerqui n'accepte également que des nombres. Si vous souhaitez renvoyer d'autres types de données depuis une fonction (texte, tableaux), la pratique courante consiste à utiliser des variables globales ou à écrire sur la sortie standard et à capturer la sortie avec $(funcion).

Ajout d'une icône de lancement graphique à un script bash sous Debian

Un autre cas très courant lorsqu'on commence à mélanger bash avec une interface graphique est celui de vouloir lancer un script à partir d'une icône dans Gnome ou depuis le gestionnaire de fichiers, sans avoir à ouvrir un terminal et à saisir la commande manuellement.

Par exemple, imaginez que vous ayez un script myscripts/doom2.sh qui exécute chocolate-doom -iwad WAD/DOOM2.WADAvez-vous essayé dans le terminal avec bash myscripts/doom2.sh Et ça fonctionne parfaitement, mais vous voulez Démarrez-le par un double-clic ou depuis un lanceur de bureau sous Debian avec Gnome.

Dans les environnements basés sur Gnome, il suffit généralement de créer un fichier .desktop en ~/.local/share/applications (pour l'utilisateur actuel) ou dans /usr/share/applications (au niveau du système), avec un contenu similaire à celui-ci :

[Desktop Entry]
Type=Application
Name=Doom 2 (Chocolate Doom)
Exec=/ruta/completa/myscripts/doom2.sh
Icon=application-x-executable
Terminal=false
Categories=Game;

Après avoir accordé les autorisations et mis à jour l'index de l'application, vous la trouverez dans le menu ou vous pourrez l'épingler au Dock. Si vous préférez la lancer en double-cliquant dessus depuis l'explorateur de fichiers, assurez-vous que le script dispose des autorisations d'exécution et que l'environnement est configuré pour exécuter les scripts texte plutôt que de les ouvrir.

En combinant cela avec des outils comme Zenity , vous pouvez créer de petites « applications » de bureau faites maison qui ne sont rien de plus que des scripts bash avec quelques boîtes de dialogue par-dessus.

Maintenant que vous maîtrisez tous les aspects, vous disposez des éléments clés pour passer de simples scripts console à des utilitaires dotés de menus graphiques ou pseudo-graphiques, accessibles à tous : menus simples avec echo/read, menus enrichis avec dialog et whiptail, boîtes de dialogue GTK avec Zenity, notifications, barres de progression et une solide base en bash : paramètres, tableaux, redirections, fonctions et gestion des erreurs. Il est temps d'expérimenter, d'adapter les exemples à vos besoins et d'optimiser l'expérience utilisateur de vos scripts jusqu'à obtenir de véritables petites applications fonctionnelles.