Accès Sécurisé

Veuillez entrer le mot de passe intranet pour déverrouiller la page.

Défis Bash Scripting

Quêtes de programmation & scripts de jeu sur Ubuntu

Retour Dashboard

Rappel : Écrire et exécuter un script sous Ubuntu

Pour développer tes scripts de défis directement dans ton terminal Ubuntu, suis toujours ces 4 étapes fondamentales :

1
Créer le fichier

Utilise l'éditeur nano pour créer et éditer ton script.

nano mon_script.sh
2
Le Shebang

Ajoute toujours cette ligne tout en haut de ton fichier.

#!/bin/bash
3
Rendre exécutable

Accorde les droits d'exécution au fichier.

chmod +x mon_script.sh
4
Lancer le script

Exécute-le directement depuis ton dossier courant.

./mon_script.sh
Défi 1 : Le Juste Prix (Guess the Number) & Leaderboard

Script de jeu interactif de devinettes avec stockage des scores.

Moyen 150 XP
L'ordinateur choisit un nombre aléatoire entre 1 et 100. Tu dois programmer une interface interactive dans la console qui te guide vers la bonne réponse en t'indiquant si c'est plus grand ou plus petit. À la fin de la partie, le script demande ton nom, l'enregistre avec ton score dans un fichier de logs, et affiche le classement (Top 5) trié du plus rapide au plus lent.
  • Initialise le nombre secret en utilisant la variable système `$RANDOM` bridée entre 1 et 100 : `SECRET=$((RANDOM % 100 + 1))`.
  • Crée une boucle `while` qui tourne tant que le nombre n'a pas été trouvé. Utilise un indicateur (ex: `TROUVE=0`).
  • Lis l'entrée utilisateur avec la commande `read -p "Proposition : " PROP` à l'intérieur de la boucle, et incrémente ton compteur de tentatives `((TENTATIVES++))`.
  • Compare la proposition : utilise une structure conditionnelle `if [ $PROP -lt $SECRET ]` pour afficher "C'est plus grand !" et `elif [ $PROP -gt $SECRET ]` pour "C'est plus petit !".
  • Enregistre le score : quand l'utilisateur gagne, utilise `read -p` pour lui demander son nom, puis ajoute une ligne au fichier `justeprix.log` contenant `tentatives;date;nom` avec l'opérateur d'écriture `>>`.
  • Génère le classement : utilise la commande `sort` avec le séparateur `;` (`-t';'`) trié numériquement sur la première colonne (`-k1 -n`) combiné avec `head -n 5` pour extraire les 5 meilleurs temps, et affiche-les proprement.
#!/bin/bash
# 1. Génération du nombre mystère et variables d'état
SECRET=$((RANDOM % 100 + 1))
TENTATIVES=0
TROUVE=0

echo "=== JEU DU JUSTE PRIX ==="
echo "Trouve le nombre secret entre 1 et 100 !"

# 2. Boucle de jeu
while [ $TROUVE -eq 0 ]; do
    read -p "Propose un nombre : " PROP
    
    # Vérification simple que l'entrée est bien un nombre
    if ! [[ "$PROP" =~ ^[0-9]+$ ]]; then
        echo "Merci d'entrer un nombre valide."
        continue
    fi
    
    ((TENTATIVES++))
    
    if [ $PROP -lt $SECRET ]; then
        echo "C'est plus grand ! ⬆️"
    elif [ $PROP -gt $SECRET ]; then
        echo "C'est plus petit ! ⬇️"
    else
        echo "🎉 Bravo ! Tu as trouvé en $TENTATIVES coups."
        TROUVE=1
    fi
done

# 3. Enregistrement du score dans justeprix.log
read -p "Entre ton nom pour le classement : " NOM
echo "$TENTATIVES;$(date '+%d/%m/%Y %H:%M');$NOM" >> justeprix.log

# 4. Lecture et affichage des 5 meilleurs scores
echo -e "\n🏆 TABLEAU DES PIONNIERS (TOP 5) :"
echo "----------------------------------------"
sort -t';' -k1 -n justeprix.log | head -n 5 | while IFS=';' read -r t d j; do
    echo "- $j : $t tentatives (le $d)"
done
echo "----------------------------------------"
            
Redirection & Tri de texte :
- `>> justeprix.log` permet d'ajouter du texte à la fin du fichier sans écraser ce qu'il contenait déjà.
- `sort -t';' -k1 -n` configure le tri : `-t';'` définit le point-virgule comme séparateur de colonnes, `-k1` trie sur la première colonne (les tentatives), et `-n` indique qu'il s'agit d'un tri numérique (pour éviter que "10" passe avant "2").
Compétence débloquée : Maîtrise des variables arithmétiques & flux de fichiers (.log)
Défi 2 : Le Mini-Dashboard Sysadmin (Ressources en Couleur)

Outil de monitoring système portable pour surveiller l'état de ta machine.

Moyen 200 XP
En tant qu'administrateur système, tu as besoin de savoir si tes serveurs ou tes postes ont assez de ressources. Tu dois écrire un script qui extrait automatiquement le pourcentage d'utilisation du disque dur, l'état d'occupation de la mémoire RAM et vérifie que la connexion réseau externe est bien active (via ping), puis affiche ces données de manière structurée et colorée.
  • Nettoie le terminal à l'exécution du script en appelant la commande `clear`.
  • Extrais l'utilisation du disque racine `/` : utilise la commande `df /`, puis filtre et découpe la chaîne de caractères (ex: avec `tail -n 1`, `awk '{print $5}'` et `cut` ou `sed` pour enlever le symbole `%`).
  • Calcule l'occupation de la RAM : récupère la mémoire totale et utilisée avec la commande `free -m`. Utilise `awk` pour capturer la deuxième et la troisième valeur de la ligne `Mem:`. Effectue l'opération de pourcentage : `POURCENTAGE=$((USED * 100 / TOTAL))`.
  • Teste la connexion Internet : fais un `ping` rapide d'un seul paquet vers un serveur public comme `8.8.8.8` avec un timeout court : `ping -c 1 -W 2 8.8.8.8 > /dev/null 2>&1`. Teste le code de retour avec `if [ $? -eq 0 ]` ou directement dans la condition.
  • Utilise les codes couleur ANSI pour formater l'affichage : vert (`\e[32m`) si tout est bon, orange/jaune (`\e[33m`) si l'occupation dépasse 70% et rouge (`\e[31m`) si la ressource est saturée (>90%) ou si le réseau est coupé. N'oublie pas de réinitialiser la couleur à la fin de chaque ligne avec `\e[0m`.
#!/bin/bash
# 1. Définition des couleurs ANSI
VERT='\e[32m'
JAUNE='\e[33m'
ROUGE='\e[31m'
BLEU='\e[34m'
NEUTRE='\e[0m'

# Nettoyage de l'écran
clear
echo -e "${BLEU}=======================================${NEUTRE}"
echo -e "${BLEU}          MONITEUR SYSTÈME UBUNTU      ${NEUTRE}"
echo -e "${BLEU}=======================================${NEUTRE}"

# 2. Récupération & Test du Disque (/)
DISK_PCT=$(df -h / | tail -n 1 | awk '{print $5}' | cut -d'%' -f1)
echo -n "Espace Disque (/) : "
if [ "$DISK_PCT" -gt 85 ]; then
    echo -e "${ROUGE}CRITIQUE ! ${DISK_PCT}% utilisé${NEUTRE}"
elif [ "$DISK_PCT" -gt 70 ]; then
    echo -e "${JAUNE}ATTENTION : ${DISK_PCT}% utilisé${NEUTRE}"
else
    echo -e "${VERT}OK - ${DISK_PCT}% utilisé${NEUTRE}"
fi

# 3. Récupération & Calcul de la RAM
RAM_TOTAL=$(free -m | grep Mem | awk '{print $2}')
RAM_USED=$(free -m | grep Mem | awk '{print $3}')
RAM_PCT=$((RAM_USED * 100 / RAM_TOTAL))
echo -n "Mémoire RAM : "
if [ "$RAM_PCT" -gt 90 ]; then
    echo -e "${ROUGE}SATURÉE ! ${RAM_PCT}% ($RAM_USED Mo / $RAM_TOTAL Mo)${NEUTRE}"
else
    echo -e "${VERT}OK - ${RAM_PCT}% ($RAM_USED Mo / $RAM_TOTAL Mo)${NEUTRE}"
fi

# 4. Test Connexion Réseau
echo -n "Connexion Internet : "
if ping -c 1 -W 2 8.8.8.8 > /dev/null 2>&1; then
    echo -e "${VERT}CONNECTÉ (Ping OK)${NEUTRE}"
else
    echo -e "${ROUGE}HORS-LIGNE (Impossible de ping 8.8.8.8)${NEUTRE}"
fi

echo -e "${BLEU}=======================================${NEUTRE}"
            
Extraction de texte avec awk et cut :
- `df -h / | tail -n 1` récupère la dernière ligne de la commande d'utilisation disque (évite la ligne d'en-tête).
- `awk '{print $5}'` isole la 5ème colonne (le pourcentage d'utilisation, par exemple `34%`).
- `cut -d'%' -f1` découpe le texte en utilisant `%` comme séparateur (`-d`) et récupère la première partie (`-f1`), nous donnant le nombre brut `34` exploitable dans une comparaison mathématique.
Compétence débloquée : Analyse de métriques système via commandes shell complexes
Défi 3 : Le Labyrinthe Interactif (Jeu d'Aventure textuel)

Jeu de rôle textuel structuré en fonctions et gérant des états d'inventaire.

Difficile 250 XP
Tu dois concevoir un jeu textuel dans le terminal représentant les locaux de 2GIK Sàrl. Le joueur commence à l'accueil et doit naviguer d'une pièce à l'autre (salle serveur, bureau Xavier) pour allumer les baies réseau et démarrer un serveur avec une clé d'installation Ubuntu. Le script doit mémoriser si le joueur a trouvé la clé USB et s'il a allumé le disjoncteur du commutateur.
  • Déclare des variables globales en haut du script pour suivre l'état du joueur (ex: `POSSEDE_CLE=0` et `SWITCH_ALLUME=0`).
  • Divise ton script en fonctions, une pour chaque salle : `salle_accueil()`, `salle_serveur()`, `salle_bureau()`. Cela évite d'avoir un code trop long et difficile à lire.
  • Implémente des menus de choix dans chaque fonction : affiche les options disponibles et récupère le choix du joueur avec `read -p "Fais ton choix : " CHOIX`.
  • Utilise une structure `case $CHOIX in` pour orienter le joueur vers d'autres fonctions. Par exemple, si le joueur choisit 1 dans l'accueil, appelle la fonction `salle_bureau`.
  • Ajoute des conditions logiques complexes : dans la salle serveur, le joueur ne peut démarrer le serveur que si `[ $POSSEDE_CLE -eq 1 ]` ET `[ $SWITCH_ALLUME -eq 1 ]`. Gère les différents cas de figure avec des messages adaptés.
  • Gère la sortie de jeu propre : utilise la commande `exit 0` quand le joueur a résolu l'énigme et gagné la partie.
#!/bin/bash
# 1. État global du joueur
POSSEDE_CLE=0
SWITCH_ALLUME=0

# 2. Fonction de la salle d'accueil
salle_accueil() {
    clear
    echo "------------------------------------------------"
    echo "Tu te trouves à l'accueil de l'atelier 2GIK."
    echo "Que souhaites-tu faire ?"
    echo "1) Aller dans le bureau de Xavier"
    echo "2) Aller dans la salle serveur"
    echo "3) Examiner la boîte de matériel sur le comptoir"
    echo "------------------------------------------------"
    read -p "Ton choix : " CHOIX
    
    case $CHOIX in
        1) salle_bureau ;;
        2) salle_serveur ;;
        3) 
            echo "Tu fouilles la boîte et trouves une Clé USB d'installation Ubuntu !"
            POSSEDE_CLE=1
            read -p "Appuie sur Entrée pour continuer..."
            salle_accueil
            ;;
        *) 
            echo "Choix invalide."
            sleep 1
            salle_accueil
            ;;
    esac
}

# 3. Fonction de la salle serveur
salle_serveur() {
    clear
    echo "------------------------------------------------"
    echo "Tu entres dans la salle serveur. Les baies ronronnent."
    echo "Un commutateur Cisco est éteint dans la baie."
    echo "1) Brancher le commutateur sur l'onduleur"
    echo "2) Insérer la clé d'installation dans le serveur"
    echo "3) Revenir à l'accueil"
    echo "------------------------------------------------"
    read -p "Ton choix : " CHOIX
    
    case $CHOIX in
        1)
            echo "Tu branches le cordon. Les LED du switch clignotent en vert ! Le réseau LAN est actif."
            SWITCH_ALLUME=1
            read -p "Appuie sur Entrée..."
            salle_serveur
            ;;
        2)
            if [ $POSSEDE_CLE -eq 1 ] && [ $SWITCH_ALLUME -eq 1 ]; then
                echo "🎉 Félicitations ! Le serveur installe Ubuntu et est accessible sur le réseau. Mission réussie !"
                exit 0
            elif [ $POSSEDE_CLE -eq 1 ]; then
                echo "Le serveur démarre, mais n'obtient pas d'adresse IP car le switch réseau est éteint..."
                read -p "Appuie sur Entrée..."
                salle_serveur
            else
                echo "Le serveur est alimenté mais n'a pas de système. Il te faut une clé d'installation."
                read -p "Appuie sur Entrée..."
                salle_serveur
            fi
            ;;
        3) salle_accueil ;;
        *)
            echo "Choix invalide."
            sleep 1
            salle_serveur
            ;;
    esac
}

# 4. Fonction du bureau
salle_bureau() {
    clear
    echo "------------------------------------------------"
    echo "Tu entres dans le bureau de Xavier. Il est absent."
    echo "Sur son écran, un pense-bête indique : 'Penser à brancher la baie de brassage !'"
    echo "1) Revenir à l'accueil"
    echo "------------------------------------------------"
    read -p "Ton choix : " CHOIX
    case $CHOIX in
        1) salle_accueil ;;
        *) salle_bureau ;;
    esac
}

# Démarrage du script
salle_accueil
            
Programmation modulaire :
- Déclarer des fonctions en Bash se fait simplement en écrivant `nom_fonction() { ... }`. Pour l'appeler plus tard dans le script, il suffit de taper son nom `nom_fonction` (sans parenthèses).
- La commande `case` permet de tester plusieurs valeurs de manière très propre. Elle se termine par l'écriture inversée `esac`. Chaque bloc de choix doit se terminer par un double point-virgule `;;`.
Compétence débloquée : Structuration modulaire d'un script Bash complexe (fonctions, états globaux)