Script Bash : mon résumé du système
Apprendre pas à pas à extraire des informations système (/proc, /sys), manipuler variables, echo et printf, et concevoir son premier script Bash automatisé et exécutable.
1. Objectifs & Démarche
Dans le travail quotidien d’un technicien ou développeur, faire l’inventaire ou le diagnostic rapide d’un poste de travail sans interface graphique est une compétence indispensable.
Plutôt que d’apprendre par cœur une longue liste de commandes isolées, ce tutoriel propose une progression méthodique en 6 étapes pas à pas :
- Lire les informations brutes au cœur du système avec
cat; - Filtrer précisément les lignes utiles avec
grepet l’option-m1; - Découper le texte avec le tube
|(pipe) et l’outilcut; - Mémoriser les résultats dans des variables avec la substitution
$( ); - Afficher et aligner les données (
echo, différence entre'et", accolades${}, etprintf) ; - Automatiser dans un script exécutable (
#!/bin/bash, droitschmod +x, exécution avec./).
2. Deux façons d’interroger Linux : Fichiers vs Commandes
Avant de commencer à coder, il est essentiel de comprendre d’où viennent les informations affichées dans votre terminal. Il ne faut pas confondre fichier, commande et variable :
| Notion | Définition & Rôle | Exemple concret |
|---|---|---|
| Un fichier système | Un document texte stocké sur le disque ou généré en direct par le noyau (/proc/, /sys/, /etc/). On ne peut pas l’exécuter, on doit le lire avec un visualiseur comme cat. |
/proc/version/etc/os-release |
| Une commande système | Un programme exécutable conçu pour effectuer un calcul ou une interrogation et afficher directement son propre résultat sans qu’on ait besoin de lire un fichier. | uname -rhostnamenproc |
| Une variable | Une zone mémoire temporaire dans laquelle on va stocker du texte ou le résultat d’une commande pour le réutiliser plus tard. | machine="thinkpad" |
Dans ce tutoriel, nous allons voir comment combiner ces deux approches : lire des fichiers système quand c’est nécessaire, et utiliser des commandes autonomes quand elles existent.
3. Étape 1 : Lire au cœur du système avec cat (approche fichiers)
Sous Linux, un principe fondateur est : « Tout est fichier ». Le noyau Linux (kernel) met à disposition des fichiers virtuels constamment mis à jour qui décrivent le matériel et l’état de la machine dans les répertoires /proc/ et /sys/.
Pour afficher le contenu d’un fichier texte dans le terminal, on utilise la commande cat (concatenate).
3.1 Un premier test réussi
Ouvre ton terminal avec le raccourci Ctrl + Alt + T et exécute :
cat /proc/versionLe système répond en affichant une ligne complète contenant la version du noyau Linux, le compilateur utilisé et la date de compilation.
3.2 La problématique : le trop-plein d’informations
Essayons maintenant de regarder les informations sur le processeur :
cat /proc/cpuinfoConstat immédiat : L’écran est instantanément envahi par des dizaines de lignes. Pourquoi ? Parce que Linux liste individuellement chaque cœur logique de ton processeur. Si la machine a 8 ou 16 cœurs, les informations se répètent en boucle. C’est illisible et inutilisable tel quel.
Dans ton terminal, teste les trois commandes suivantes et observe ce qu’elles renvoient :
- Affiche le fichier d’identification de ta distribution :
Terminal cat /etc/os-release - Affiche les statistiques de mémoire vive :
Terminal cat /proc/meminfo - Affiche le pourcentage de charge de la batterie de ton ThinkPad :
Terminal cat /sys/class/power_supply/BAT0/capacity
Question : Quel est le problème commun entre /proc/cpuinfo et /proc/meminfo par rapport à la batterie ?
4. Étape 2 : Cibler la bonne ligne avec grep et grep -m1
Puisque les fichiers comme /proc/cpuinfo ou /proc/meminfo contiennent trop de texte, nous devons filtrer pour n’extraire que la ligne qui nous intéresse. C’est exactement le rôle de grep.
4.1 Filtrer par mot-clé avec grep
La commande grep mot-clé fichier parcourt le fichier et affiche uniquement les lignes contenant ce mot-clé.
Exemple sur un texte imaginaire :
Si un fichier "notes.txt" contient :Fruit : pommeLegume : carotte
La commande "grep pomme notes.txt" affiche uniquement :Fruit : pommeAppliquons cela à notre processeur pour trouver son nom de modèle (model name) :
grep 'model name' /proc/cpuinfoRésultat : On ne voit plus tout le fichier, mais la ligne apparaît encore autant de fois que le processeur a de cœurs.
4.2 Ne garder que la première occurrence avec -m1
L’option -m (max-count) indique à grep de s’arrêter dès qu’il a trouvé un certain nombre de résultats. En demandant un maximum de 1 (-m1) :
grep -m1 'model name' /proc/cpuinfoRésultat : Une seule et unique ligne apparaît :
model name : Intel(R) Core(TM) i5-1135G7 @ 2.40GHz
- Dans le fichier
/proc/meminfo, utilisegreppour afficher uniquement la ligne donnant la mémoire totale (MemTotal). - Dans
/etc/os-release, utilisegreppour trouver la ligne contenant le nom complet de la distribution (PRETTY_NAME). - Dans
/proc/cpuinfo, utilisegrep -m1pour trouver la fréquence de fonctionnement du processeur (cpu MHz).
5. Étape 3 : Découper l’information avec le tube | et cut
Regarde bien le résultat obtenu à l’étape précédente :
model name : Intel(R) Core(TM) i5-1135G7 @ 2.40GHz
Le préfixe model name : est redondant. Pour construire un tableau de bord propre, nous ne voulons garder que ce qui est situé après le caractère deux-points :.
5.1 Découper avec cut
La commande cut permet de découper une ligne en colonnes :
-d(delimiter) : indique le caractère qui sert de séparateur entre les colonnes (par exemple:ou=).-f(field) : indique le numéro de la colonne à conserver.-f1: tout ce qui se trouve avant le séparateur ;-f2: tout ce qui se trouve après le séparateur.
Exemple :
echo "Serveur:Debian" | cut -d: -f1 # renvoie : Serveurecho "Serveur:Debian" | cut -d: -f2 # renvoie : Debian5.2 Relier deux commandes avec le tube | (Pipe)
Au lieu d’enregistrer le résultat de grep dans un fichier intermédiaire pour ensuite le donner à cut, on relie directement les deux commandes grâce au symbole | (le pipe, accessible au clavier avec la combinaison AltGr + 6).
La sortie de la commande de gauche est injectée immédiatement comme entrée de la commande de droite :
Testons l’enchaînement complet :
grep -m1 'model name' /proc/cpuinfo | cut -d: -f2Résultat : Le nom du modèle du processeur s’affiche désormais sans son étiquette initiale !
Sur certaines lignes comme dans /etc/os-release, la valeur est entourée de guillemets (ex. "Debian GNU/Linux 12"). Pour retirer ces guillemets, on peut ajouter un second tube avec l’outil de suppression de caractères tr :
grep '^PRETTY_NAME' /etc/os-release | cut -d= -f2 | tr -d '"'- En une seule ligne de commande chaînée (
grep+|+cut), isole la valeur de la mémoire totale à partir du fichier/proc/meminfo. - Observe ce que renvoie la commande système
hostname -I(qui affiche tes adresses réseau). En utilisant un tube etcut -d' ' -f1(séparateur espace), isole la première adresse IP de la liste. - À partir du fichier
/etc/os-release, isole uniquement le nom de la distribution sans son préfixePRETTY_NAME=et sans les guillemets.
6. Étape 4 : Les commandes systèmes autonomes (sans fichier à lire)
Jusqu’ici, nous avons extrait des données en fouillant dans des fichiers (/proc/, /etc/). Mais Linux dispose également d’une multitude de commandes systèmes autonomes : ce sont des exécutables programmés pour interroger directement le matériel ou le système d’exploitation et renvoyer une valeur toute prête.
4.1 Quelques commandes autonomes utiles
Teste ces commandes dans ton terminal :
uname -r # Affiche directement la version exacte du noyau (ex: 6.1.0-25-amd64)hostname # Affiche directement le nom réseau de ta machinenproc # Compte et affiche directement le nombre de cœurs CPUdate # Affiche la date et l'heure couranteRemarque la différence fondamentale :
- Pour
/proc/version, on a dû tapercat /proc/version(car c’est un fichier). - Pour
uname -r, on ne tape pascat, on lance directement la commandeuname(car c’est un programme exécutable).
7. Étape 5 : Mémoriser dans des variables avec $( )
Pour concevoir un script qui produira un rapport propre, nous ne voulons pas afficher ces données au fur et à mesure de manière désordonnée. Nous allons les stocker dans des variables, qu’elles proviennent d’une commande autonome ou d’une extraction de fichier.
5.1 Déclarer et lire une variable simple
Une variable est une boîte étiquetée qui retient une valeur en mémoire vive :
- Règle capitale en Bash : aucun espace de part et d’autre du signe égal
=lors de l’affectation. - Pour lire le contenu d’une variable, on précède son nom d’un dollar
$.
# Correct :prenom="Alice"echo $prenom
# ERREUR CLASSIQUE (Bash cherche un programme nommé "prenom" !) :prenom = "Alice"5.2 Ranger le résultat d’une commande dans une variable : $( )
Le mécanisme de substitution de commande s’écrit $( ... ). Bash exécute la commande placée à l’intérieur des parenthèses et injecte son résultat directement dans la variable.
On peut y ranger aussi bien le résultat d’une commande système autonome que celui d’une commande de lecture de fichier :
# Stocker le résultat d'une commande autonome :noyau=$(uname -r)machine=$(hostname)
# Stocker le résultat d'une lecture de fichier découpée :cpu=$(grep -m1 'model name' /proc/cpuinfo | cut -d: -f2)Ces informations sont désormais stockées en mémoire ! Pour vérifier ce qu’elles contiennent :
echo $noyauecho $machineecho $cpu5.3 Les variables d’environnement déjà prêtes
Linux pré-remplit automatiquement certaines variables utiles pour votre session :
$USER: ton identifiant de session ;$HOSTNAME: le nom réseau de ta machine ;$HOME: le chemin de ton dossier personnel (/home/...).
- Déclare une variable
oscontenant le nom extrait du fichier/etc/os-releasevia$( ). - Déclare une variable
ipcontenant ta première adresse IP via la commande autonome et son découpage :$(hostname -I | cut -d' ' -f1). - Déclare une variable
batteriecontenant la valeur lue dans le fichier/sys/class/power_supply/BAT0/capacity. - Affiche le contenu de chacune de ces 3 variables avec
echo.
8. Étape 6 : L’art de l’affichage : echo, guillemets et printf
Maintenant que nous savons collecter et stocker les données, apprenons à les restituer avec clarté.
6.1 Accoler une variable à du texte avec les accolades ${}
Quand une variable est suivie immédiatement d’autres lettres ou d’un tiret bas, Bash peut confondre le nom de la variable. Pour délimiter précisément son nom, on l’entoure d’accolades :
poste="thinkpad"echo "Machine : ${poste}_sio" # Affiche : Machine : thinkpad_sioecho "Machine : $poste_sio" # N'affiche rien pour la variable : $poste_sio n'existe pas !6.2 Le piège fondamental : Guillemets doubles " vs Apostrophes simples '
C’est une règle essentielle du Shell :
- Les guillemets doubles
": Bash lit et interprète les variables ($variableest remplacé par son contenu). - Les apostrophes simples
': Bash protège le texte de manière brute sans rien interpréter.
Teste la différence :
distribution="Debian"
# Avec guillemets doubles :echo "Mon système est $distribution"# Résultat : Mon système est Debian
# Avec apostrophes simples :echo 'Mon système est $distribution'# Résultat : Mon système est $distribution6.3 Aligner des colonnes avec printf
La commande echo passe toujours à la ligne mais ne permet pas d’aligner des textes de longueurs différentes.
La commande printf permet de formater l’affichage et de créer des colonnes parfaitement alignées :
%-20s: réserve une colonne de 20 caractères, texte aligné à gauche ;%s: affiche une chaîne de caractères ;\n: insère le saut de ligne (newline, équivalent de la touche Entrée).
Compare ces deux affichages :
# Avec echo (résultat bancal) :echo "Machine: $machine"echo "Version du noyau: $noyau"
# Avec printf (résultat professionnel aligné) :printf '%-20s : %s\n' "Machine" "$machine"printf '%-20s : %s\n' "Version du noyau" "$noyau"Résultat de printf :
Machine : debian-sioVersion du noyau : 6.1.0-25-amd64- En utilisant
echoavec des guillemets doubles et les variables$USERet$HOSTNAME, affiche la phrase :Session ouverte pour l'utilisateur [ton_user] sur la machine [ta_machine]. - En utilisant
echoavec des apostrophes simples, affiche textuellement à l’écran :La syntaxe $(commande) permet de capturer la sortie. - Avec
printf, affiche deux lignes alignées sur une largeur de colonne de 15 caractères :- Colonne 1 :
Utilisateur/ Colonne 2 :$USER - Colonne 1 :
IP/ Colonne 2 :$ip
- Colonne 1 :
9. Étape 7 : L’assemblage : concevoir son premier script exécutable
Plutôt que de retaper ces commandes à chaque fois, nous allons les enregistrer dans un fichier script réutilisable.
7.1 Créer et éditer le fichier
Pour rédiger un script, ouvre un éditeur de texte (VS Code avec code systeme.sh, ou l’éditeur en console nano systeme.sh) et crée un nouveau fichier nommé systeme.sh.
7.2 La règle obligatoire : le Shebang (#!/bin/bash)
La toute première ligne d’un script Bash doit impérativement être le shebang :
#!/bin/bashCette ligne indique au système d’exploitation avec quel interpréteur exécuter le contenu du fichier.
7.3 Structure complète du script
Voici un exemple de script commenté assemblant toutes les notions abordées :
#!/bin/bash# ==============================================================# Script de diagnostic poste de travail# Auteur : SIO# ==============================================================
# 1. Collecte des données dans des variablesmachine=$(hostname)noyau=$(uname -r)cpu=$(grep -m1 'model name' /proc/cpuinfo | cut -d: -f2)memoire=$(grep MemTotal /proc/meminfo | cut -d: -f2)date_du_jour=$(date '+%d/%m/%Y à %H:%M')
# 2. Affichage de l'en-têteecho "=============================================="echo " RAPPORT SYSTEME DU POSTE "echo " Généré le $date_du_jour "echo "=============================================="echo
# 3. Restitution alignéeprintf '%-20s : %s\n' "Utilisateur" "$USER"printf '%-20s : %s\n' "Nom d'hôte" "$machine"printf '%-20s : %s\n' "Noyau Linux" "$noyau"printf '%-20s : %s\n' "Modèle processeur" "$cpu"printf '%-20s : %s\n' "Mémoire totale" "$memoire"
echoecho "=============================================="Enregistre ton fichier.
7.4 Comment exécuter son script ?
Il existe deux manières d’exécuter un script :
Méthode A : Exécution via l’interpréteur
bash systeme.shCette commande demande explicitement au programme bash de lire et exécuter les instructions de systeme.sh.
Méthode B : Rendre le script autonome avec chmod +x (Méthode pro)
Pour pouvoir exécuter un script directement comme n’importe quelle commande système :
- Donne le droit d’exécution au fichier avec la commande
chmod(change mode) :Terminal chmod +x systeme.sh - Vérifie avec
ls -l systeme.sh: le fichier possède désormais la lettrex(executable) dans ses permissions et s’affiche souvent en vert. - Exécute le script en indiquant son chemin relatif :
(Le
Terminal ./systeme.sh./précise à Linux de chercher le fichier dans le dossier courant).
- Dans ton éditeur (VS Code ou nano), saisis le script
systeme.shprésenté ci-dessus. - Rends-le exécutable dans ton terminal avec la commande :
Terminal chmod +x systeme.sh - Lance-le avec
./systeme.shet vérifie que toutes les informations s’affichent correctement et de manière bien alignée.
10. Exercice de synthèse : enrichir et documenter son script
À partir de la base systeme.sh fonctionnelle, tu vas maintenant enrichir ton rapport en y intégrant de nouvelles informations et en soignant la présentation visuelle.
Consignes de personnalisation
- Intégrer une bannière ASCII avec
figlet:- Si ce n’est pas déjà fait, installe l’outil avec
sudo apt install figlet -y. - Ajoute au tout début de l’affichage (juste après l’en-tête de commentaires) une commande
figletpour afficher un titre percutant, par exemple :Terminal figlet "THINKPAD"
- Si ce n’est pas déjà fait, installe l’outil avec
- Ajouter 3 nouvelles informations système précises :
Consulte la Boîte à outils ci-dessous (§ 11) pour trouver les commandes ou fichiers adéquats, et crée 3 nouvelles variables dans ton script :
- La distribution Linux (extraite de
/etc/os-releaseavecgrep,cutettr) ; - Le niveau de batterie actuel (lu dans
/sys/class/power_supply/BAT0/capacity) ; - La durée d’activité du poste (uptime, avec
uptime -p).
- La distribution Linux (extraite de
- Mettre en forme l’affichage :
- Ajoute les lignes
printfcorrespondantes pour afficher ces 3 informations avec le même alignement que les précédentes.
- Ajoute les lignes
- Documenter chaque ligne avec des commentaires :
- Ajoute au-dessus ou en bout de ligne un commentaire explicatif précédé de
#pour chaque variable et chaque bloc de commande (indiquer précisément ce que la commande va chercher ou ce que le bloc affiche).
- Ajoute au-dessus ou en bout de ligne un commentaire explicatif précédé de
Exemple d’exécution attendu
_ _ _ _ ____ _| |_| |__ (_)_ __ | | __ | _ \ __ _ __| || __| '_ \| | '_ \| |/ / | |_) / _` |/ _` || |_| | | | | | | | < | __/ (_| | (_| | \__|_| |_|_|_| |_|_|\_\ |_| \__,_|\__,_|
============================================== RAPPORT SYSTEME DU POSTE Généré le 27/09/2026 à 14:30==============================================
Utilisateur : davyNom d'hôte : thinkpad-sioDistribution : Debian GNU/Linux 12 (bookworm)Noyau Linux : 6.1.0-25-amd64Modèle processeur : 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHzMémoire totale : 16198276 kBBatterie restante : 92%Activité (uptime) : up 2 hours, 15 minutes
==============================================Checklist d’auto-évaluation
- Le script commence obligatoirement par
#!/bin/bash; - Une bannière générée par
figlets’affiche au début du rapport ; - Les 3 nouvelles variables (Distribution, Batterie, Uptime) sont collectées via
$( ); - Toutes les valeurs sont restituées avec
printf '%-20s : %s\n'pour un alignement parfait ; - Chaque ligne de code est commentée avec
#pour expliquer son rôle ; - Le script s’exécute de façon autonome avec
./systeme.sh.
11. Pour aller plus loin : Boîte à outils des sondes système
Maintenant que tu maîtrises l’extraction et les variables, voici le catalogue des sondes et commandes complémentaires dans lequel tu peux piocher pour enrichir tes scripts :
| Pour savoir… | Commande ou fichier source | Exemple d’extraction |
|---|---|---|
| Version complète du noyau | uname -a |
$(uname -a) |
| Version courte du noyau | uname -r |
$(uname -r) |
| Distribution Linux | /etc/os-release |
$(grep '^PRETTY_NAME' /etc/os-release | cut -d= -f2 | tr -d '"') |
| Modèle de la machine | /sys/class/dmi/id/product_version |
$(cat /sys/class/dmi/id/product_version) |
| Version du BIOS | /sys/class/dmi/id/bios_version |
$(cat /sys/class/dmi/id/bios_version) |
| Nombre de cœurs processeur | nproc |
$(nproc) |
| Modèle du processeur | /proc/cpuinfo |
$(grep -m1 'model name' /proc/cpuinfo | cut -d: -f2) |
| Mémoire RAM (vue d’ensemble) | free -h |
free -h (affiche le tableau complet) |
| Mémoire RAM totale (brute) | /proc/meminfo |
$(grep MemTotal /proc/meminfo | cut -d: -f2) |
| Espace disque disponible | df -h / |
df -h / (affiche le résumé de la partition racine) |
| Liste des disques et partitions | lsblk |
lsblk |
| Adresses IP et interfaces | ip -brief addr |
ip -brief addr |
| Première adresse IP locale | hostname -I |
$(hostname -I | cut -d' ' -f1) |
| Durée d’activité de la machine | uptime -p |
$(uptime -p) |
| Niveau de batterie | /sys/class/power_supply/BAT0/capacity |
$(cat /sys/class/power_supply/BAT0/capacity)% |
| Date et heure formatées | date |
$(date '+%d/%m/%Y %H:%M') |
Toutes les commandes présentées dans ce tutoriel sont en lecture seule : elles consultent la configuration sans altérer le système. Ne lance jamais une commande que tu ne comprends pas, particulièrement si elle est précédée de sudo.
Ressources associées
Ligne de commande Linux : navigation, flux standards et commandes usuelles
Maîtrise du terminal shell Bash : arborescence, chemins absolus et relatifs, manipulation des flux standards (stdin, stdout, stderr), tubes (pipes) et outils de filtrage (cat, grep, cut, sort).
Commandes de base, variables et scripts Bash
Quiz interactif complet en 31 questions : terminal et shell, navigation et chemins (pwd, ls, ~, relatifs), norme POSIX, les 3 sources de données (fichiers, commandes, variables système, env), filtrage et tubes (cat, grep -m1, cut, pipe), syntaxe des variables Bash, echo vs printf, shebang et exécution autonome (bash, chmod +x, ./).
Usage avancé des commandes avec Gameshell
Guide pas-à-pas et carnet de bord pour relever l'immersion GameShell dans le terminal : installation sous Debian, réflexes vitaux (Tab, Ctrl+C, pwd), ordres de l'arbitre gsh et production du livrable ODT recensant les commandes.
Valorisation E4 — Compétences travaillées
En quoi les gestes techniques de cette ressource valident chaque compétence du référentiel (base du portfolio d'épreuve E4).
- C-1.2.2Traiter des demandes concernant les services réseau et système, applicatifs
Diagnostic du poste par commandes (uname, hostnamectl, lscpu, free, df, ip, uptime) et fichiers noyau (/proc, /sys).
- C-1.2.3Traiter des demandes concernant les applications
Lecture et écriture d'un script systeme.sh exécutable : shebang, variables, $( ), echo et printf.