Retour aux travaux pratiques
Travaux pratiques
24 septembre 2026

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.

#tuto#bash#script#diagnostic#systeme#variables#echo#printf#proc
Système

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 :

  1. Lire les informations brutes au cœur du système avec cat ;
  2. Filtrer précisément les lignes utiles avec grep et l’option -m1 ;
  3. Découper le texte avec le tube | (pipe) et l’outil cut ;
  4. Mémoriser les résultats dans des variables avec la substitution $( ) ;
  5. Afficher et aligner les données (echo, différence entre ' et ", accolades ${}, et printf) ;
  6. Automatiser dans un script exécutable (#!/bin/bash, droits chmod +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 -r
hostname
nproc
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 :

Terminal
cat /proc/version

Le 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 :

Terminal
cat /proc/cpuinfo

Constat 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 :

  1. Affiche le fichier d’identification de ta distribution :
    Terminal
    cat /etc/os-release
  2. Affiche les statistiques de mémoire vive :
    Terminal
    cat /proc/meminfo
  3. 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 :

Sortie
Si un fichier "notes.txt" contient :
Fruit : pomme
Legume : carotte
La commande "grep pomme notes.txt" affiche uniquement :
Fruit : pomme

Appliquons cela à notre processeur pour trouver son nom de modèle (model name) :

Terminal
grep 'model name' /proc/cpuinfo

Ré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) :

Terminal
grep -m1 'model name' /proc/cpuinfo

Résultat : Une seule et unique ligne apparaît : model name : Intel(R) Core(TM) i5-1135G7 @ 2.40GHz

  1. Dans le fichier /proc/meminfo, utilise grep pour afficher uniquement la ligne donnant la mémoire totale (MemTotal).
  2. Dans /etc/os-release, utilise grep pour trouver la ligne contenant le nom complet de la distribution (PRETTY_NAME).
  3. Dans /proc/cpuinfo, utilise grep -m1 pour 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 :

Sortie
echo "Serveur:Debian" | cut -d: -f1 # renvoie : Serveur
echo "Serveur:Debian" | cut -d: -f2 # renvoie : Debian

5.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 :

Tube : la sortie de commande1 devient l'entrée de commande2 la sortie devient l'entrée grep ... cut ... | produit du texte (stdout) lit le texte filtré (stdin)

Testons l’enchaînement complet :

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

Ré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 :

Terminal
grep '^PRETTY_NAME' /etc/os-release | cut -d= -f2 | tr -d '"'
  1. En une seule ligne de commande chaînée (grep + | + cut), isole la valeur de la mémoire totale à partir du fichier /proc/meminfo.
  2. Observe ce que renvoie la commande système hostname -I (qui affiche tes adresses réseau). En utilisant un tube et cut -d' ' -f1 (séparateur espace), isole la première adresse IP de la liste.
  3. À partir du fichier /etc/os-release, isole uniquement le nom de la distribution sans son préfixe PRETTY_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 :

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 machine
nproc # Compte et affiche directement le nombre de cœurs CPU
date # Affiche la date et l'heure courante

Remarque la différence fondamentale :

  • Pour /proc/version, on a dû taper cat /proc/version (car c’est un fichier).
  • Pour uname -r, on ne tape pas cat, on lance directement la commande uname (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 $.
Terminal
# 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 :

Terminal
# 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 :

Terminal
echo $noyau
echo $machine
echo $cpu

5.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/...).
  1. Déclare une variable os contenant le nom extrait du fichier /etc/os-release via $( ).
  2. Déclare une variable ip contenant ta première adresse IP via la commande autonome et son découpage : $(hostname -I | cut -d' ' -f1).
  3. Déclare une variable batterie contenant la valeur lue dans le fichier /sys/class/power_supply/BAT0/capacity.
  4. 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 :

Terminal
poste="thinkpad"
echo "Machine : ${poste}_sio" # Affiche : Machine : thinkpad_sio
echo "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 ($variable est remplacé par son contenu).
  • Les apostrophes simples ' : Bash protège le texte de manière brute sans rien interpréter.

Teste la différence :

Terminal
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 $distribution

6.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 :

Terminal
# 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 :

Sortie
Machine : debian-sio
Version du noyau : 6.1.0-25-amd64
  1. En utilisant echo avec des guillemets doubles et les variables $USER et $HOSTNAME, affiche la phrase : Session ouverte pour l'utilisateur [ton_user] sur la machine [ta_machine].
  2. En utilisant echo avec des apostrophes simples, affiche textuellement à l’écran : La syntaxe $(commande) permet de capturer la sortie.
  3. 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

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 :

Fichier script
#!/bin/bash

Cette 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 :

systeme.sh
#!/bin/bash
# ==============================================================
# Script de diagnostic poste de travail
# Auteur : SIO
# ==============================================================
# 1. Collecte des données dans des variables
machine=$(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ête
echo "=============================================="
echo " RAPPORT SYSTEME DU POSTE "
echo " Généré le $date_du_jour "
echo "=============================================="
echo
# 3. Restitution alignée
printf '%-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"
echo
echo "=============================================="

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

Terminal
bash systeme.sh

Cette 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 :

  1. Donne le droit d’exécution au fichier avec la commande chmod (change mode) :
    Terminal
    chmod +x systeme.sh
  2. Vérifie avec ls -l systeme.sh : le fichier possède désormais la lettre x (executable) dans ses permissions et s’affiche souvent en vert.
  3. Exécute le script en indiquant son chemin relatif :
    Terminal
    ./systeme.sh
    (Le ./ précise à Linux de chercher le fichier dans le dossier courant).
  1. Dans ton éditeur (VS Code ou nano), saisis le script systeme.sh présenté ci-dessus.
  2. Rends-le exécutable dans ton terminal avec la commande :
    Terminal
    chmod +x systeme.sh
  3. Lance-le avec ./systeme.sh et 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

  1. 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 figlet pour afficher un titre percutant, par exemple :
      Terminal
      figlet "THINKPAD"
  2. 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-release avec grep, cut et tr) ;
    • Le niveau de batterie actuel (lu dans /sys/class/power_supply/BAT0/capacity) ;
    • La durée d’activité du poste (uptime, avec uptime -p).
  3. Mettre en forme l’affichage :
    • Ajoute les lignes printf correspondantes pour afficher ces 3 informations avec le même alignement que les précédentes.
  4. 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).

Exemple d’exécution attendu

Sortie
_ _ _ _ ____ _
| |_| |__ (_)_ __ | | __ | _ \ __ _ __| |
| __| '_ \| | '_ \| |/ / | |_) / _` |/ _` |
| |_| | | | | | | | < | __/ (_| | (_| |
\__|_| |_|_|_| |_|_|\_\ |_| \__,_|\__,_|
==============================================
RAPPORT SYSTEME DU POSTE
Généré le 27/09/2026 à 14:30
==============================================
Utilisateur : davy
Nom d'hôte : thinkpad-sio
Distribution : Debian GNU/Linux 12 (bookworm)
Noyau Linux : 6.1.0-25-amd64
Modèle processeur : 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz
Mémoire totale : 16198276 kB
Batterie 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 figlet s’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

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.