Script Bash : mon résumé du système

1. Objectifs

À la fin de ce TP, tu sauras :

1. Utiliser des commandes simples pour lire la configuration de ton PC : noyau, CPU, mémoire, disque, réseau, batterie… ;
2. Lire ces informations de deux façons : par des commandes (uname, free, df…) et par des fichiers particuliers (/proc/, /sys/) ;
3. Écrire ton premier script Bash, c’est-à-dire un fichier texte qui enchaîne des commandes ;
4. Utiliser les variables et echo pour afficher un résumé du système, avec la mise en forme de ton choix.

2. Trois termes à retenir

Un script (ou « script shell ») est un fichier texte dans lequel on écrit des commandes. Bash les exécute les unes après les autres, comme si elles étaient saisies manuellement.

3. Les commandes utiles pour lire le système

Deux façons d’obtenir une information :

1. Une commande : uname -a, free -h, df -h… (un programme dédié) ;
2. Un fichier : les fichiers de /proc/ et /sys/ sont des fichiers virtuels renseignés en direct par le noyau. Ils se lisent comme des fichiers ordinaires, avec cat, grep ou head :

cat /proc/meminfo          # tout le fichier
grep MemTotal /proc/meminfo  # seulement la ligne qui contient MemTotal
head -5 /proc/cpuinfo      # seulement les 5 premières lignes

Le tableau suivant recense les commandes et fichiers utiles. Exécute chaque commande et observe le résultat affiché.

3.1 Chercher, découper et enchaîner : grep, cut et le tube |

Trois outils complémentaires permettent d’exploiter ces fichiers : grep pour filtrer, cut pour découper, et le tube | pour les enchaîner.

grep : afficher seulement les lignes qui contiennent un mot

grep mot fichier affiche uniquement les lignes du fichier qui contiennent mot. Exemple sur des données fictives illustrant le mécanisme :

>>> cat exemple.txt            # le fichier contient :
Fruit : pomme
Legume : carotte

>>> grep pomme exemple.txt     # grep garde seulement les lignes contenant "pomme"
Fruit : pomme

Ces fichiers système étant souvent volumineux, ce filtrage est indispensable :

grep 'model name' /proc/cpuinfo        # les lignes qui contiennent "model name"
grep MemTotal /proc/meminfo            # la ligne du total de mémoire
grep '^PRETTY_NAME' /etc/os-release    # ^ = la ligne qui commence par PRETTY_NAME

/proc/cpuinfo contient une ligne par cœur logique. Pour ne garder que la première, on ajoute -m1 (m = maximum) :

grep -m1 'model name' /proc/cpuinfo

Le tube | : envoyer la sortie d’une commande dans la suivante

Le symbole | (le « tube », pipe en anglais) connecte deux commandes : la sortie de celle de gauche devient l’entrée de celle de droite.

Exemple : afficher seulement la première ligne trouvée par grep :

grep 'model name' /proc/cpuinfo | head -1

cut : découper une ligne en morceaux

cut coupe une ligne en colonnes : avec -d on indique le séparateur (le délimiteur), avec -f on choisit la colonne à garder. Exemple sur des données fictives :

>>> echo "Fruit:pomme" | cut -d: -f1
Fruit
>>> echo "Fruit:pomme" | cut -d: -f2
pomme

• colonne 1 (-f1) = tout ce qui est avant le premier : ;
• colonne 2 (-f2) = tout ce qui est après le premier :.

Le modèle du processeur figure sur une ligne de la forme model name : <nom du processeur>. On cherche cette ligne avec grep, puis on garde ce qui suit le : avec cut :

grep -m1 'model name' /proc/cpuinfo | cut -d: -f2

Même principe pour la distribution : le nom est la partie qui suit le = dans /etc/os-release :

grep '^PRETTY_NAME' /etc/os-release | cut -d= -f2

4. Les bases du script Bash

Cette section présente les bases nécessaires. Reproduire chaque exemple dans un fichier, puis l’exécuter.

4.1 Mon premier script

Crée un fichier essai.sh et écris-y :

echo "Bonjour, je suis un script !"

Lance-le avec :

bash essai.sh

Le script s’exécute et affiche le message.

4.2 Le shebang : déclarer l’interpréteur

La toute première ligne d’un script Bash est presque toujours :

#!/bin/bash
echo "Bonjour, je suis un script !"

Cette ligne (le shebang) indique au système que le fichier doit être exécuté avec le programme Bash. Elle se place tout en haut, sur la première ligne.

Une autre façon de lancer un script : le rendre exécutable, puis le lancer par son nom :

chmod +x essai.sh     # donne le droit d'exécution (une fois pour toutes)
./essai.sh            # lance le script (./ = dans le dossier courant)

Pour créer ou modifier un script, on utilise un éditeur de texte :

nano essai.sh         # éditer (enregistrer : Ctrl+O, Entrée ; quitter : Ctrl+X)

4.3 Les commentaires

Toute ligne qui commence par # est un commentaire : Bash l’ignore. Les commentaires documentent le script, pour toi comme pour les autres.

#!/bin/bash
# Mon premier script — écrit par moi
# La ligne suivante affiche un message :
echo "Bonjour !"

4.4 Les variables : nommer des valeurs

Une variable est un nom associé à du texte ou un nombre.

#!/bin/bash
prenom="Alice"              # stocke "Alice" dans la variable prenom
echo "Bonjour $prenom"      # $prenom = le contenu de la variable
echo "Bonjour ${prenom} !"  # accolades utiles si du texte touche le nom

À retenir :

• Pour stocker : nom="valeur" → aucun espace autour du = ;
• Pour lire : $nom ou ${nom} ;
• Les guillemets "…" permettent d’écrire des phrases avec espaces.

Il existe aussi des variables déjà renseignées par le système :

#!/bin/bash
echo "Je m'appelle $USER, ma machine est $HOSTNAME."
echo "Mon dossier personnel : $HOME"

$USER, $HOSTNAME et $HOME prennent automatiquement les valeurs du poste.

4.5 Ranger une commande dans une variable : $( )

La substitution de commande $( commande ) exécute une commande et récupère sa sortie pour la ranger dans une variable :

#!/bin/bash
noyau="$(uname -r)"         # noyau = la sortie de "uname -r"
echo "La version du noyau est : $noyau"

On peut aussi l’utiliser directement dans un message :

#!/bin/bash
echo "Machine : $(hostname)"
echo "Cœurs : $(nproc)"

C’est ce mécanisme qui relie les commandes du § 3 au script : tester une commande, puis ranger sa sortie dans une variable avec $( ).

4.6 Afficher et mettre en forme : echo et printf

echo affiche simplement, puis passe à la ligne :

echo "Texte"        # affiche puis passe à la ligne
echo -n "Texte"     # affiche sans passer à la ligne (-n)
echo                # affiche une ligne vide (pour aérer)

printf offre un meilleur contrôle : il aligne les colonnes. C’est l’outil adapté pour présenter des étiquettes et des valeurs :

#!/bin/bash
printf '%-20s %s\n' "Étiquette" "Valeur"
printf '%-20s %s\n' "Noyau" "$(uname -r)"
printf '%-20s %s\n' "Machine" "$(hostname)"

À retenir sur printf :

• %-20s → un texte aligné à gauche sur 20 caractères (les suivants s’alignent au même endroit) ;
• %s → texte, %d → nombre entier ;
• \n → fin de ligne (comme la touche Entrée).

5. Le TP principal : « Mon résumé du système »

La consigne

Écris un script systeme.sh qui affiche un résumé de ton système : un titre, puis les informations de ton choix, présentées selon tes choix.

Choisir librement :

• quelles informations afficher (dans le § 3) ;
• dans quel ordre ;
• avec quelle présentation (séparateurs, lignes vides, colonnes…).

Aucun modèle n’est imposé : la construction du script est libre.

Étapes conseillées

1. Commencer petit. Crée systeme.sh avec le shebang et un titre : affiche par exemple Mon système avec echo.
2. Ajouter les premières informations. Range 3 informations dans des variables avec $( ) (ex. : noyau, machine, utilisateur) et affiche-les avec echo.
3. Compléter. Ajoute les sections utiles : Processeur, Mémoire, Disque, Réseau, Batterie, Température… (reprends les commandes du § 3).
4. Mettre en forme. Aère la sortie : lignes vides, séparateurs, titre bien visible. Expérimente echo et printf jusqu’à obtenir un affichage satisfaisant.
5. Relire et commenter. Commente chaque partie avec des # pour expliquer son rôle. Vérifie le fonctionnement en relançant le script.

Idées de présentation

Voici un exemple d’assemblage dans systeme.sh combinant en-tête et alignement :

#!/bin/bash
echo "=============================================="
echo "  Mon système — $(date '+%d/%m/%Y %H:%M')"
echo "=============================================="
echo                                   # une ligne vide

printf '%-15s %s\n' "Noyau:" "$(uname -r)"
printf '%-15s %s\n' "Machine:" "$(hostname)"

D’autres présentations sont possibles (séparateurs, sections, colonnes…) : l’essentiel est un affichage clair et lisible.

Critères de réussite (à vérifier avant de rendre)

• Le script se lance avec bash systeme.sh (ou ./systeme.sh) ;
• Il commence par #!/bin/bash et contient des commentaires # ;
• Il affiche un titre bien visible ;
• Il affiche au moins 6 informations du § 3, exactes (vérifier au besoin avec les commandes isolées) ;
• Il utilise au moins 3 variables (dont au moins une avec $( )) ;
• La présentation est soignée (lignes vides, séparateurs ou colonnes) ;
• La sortie est lisible par un autre élève sans explication.

Bonus (facultatif)

1. Affiche la température du processeur en degrés (voir la conversion des milli-degrés).
2. Affiche la batterie en % avec un message comme Batterie : 98 %.
3. Enregistre la sortie du script dans un fichier texte, pour garder une trace : bash systeme.sh > fiche_systeme.txt.

6. Pour aller plus loin

if (conditions), for (boucles), $1 (arguments du script) et man bash (manuel complet) ouvrent de nouvelles possibilités. Ces notions dépassent le cadre de ce TP, centré sur l’exécution de commandes, la lecture de fichiers et l’affichage avec echo.