32 - Systèmes (shell)

Cours associé : 23 - Systèmes d’exploitation .

QCM – vérification des prérequis

Pour chaque question, une seule réponse est correcte.

1. Quelle commande affiche le contenu du répertoire courant ?

  • A. cd
  • B. ls
  • C. pwd
  • D. cat

Correction publiée après la séance.

2. Que fait la commande cd .. ?

  • A. Elle crée un nouveau dossier
  • B. Elle remonte au répertoire parent
  • C. Elle supprime le répertoire courant
  • D. Elle affiche le chemin absolu du répertoire courant

Correction publiée après la séance.

3. Quelle est la différence entre un chemin absolu et un chemin relatif ?

  • A. Un chemin absolu commence par le nom d’un fichier, un chemin relatif par /
  • B. Un chemin absolu commence par / (la racine), un chemin relatif part du répertoire courant
  • C. Il n’y a aucune différence
  • D. Un chemin relatif ne peut désigner que des fichiers, pas des dossiers

Correction publiée après la séance.

4. Que fait la commande cp fichier.txt copie.txt ?

  • A. Elle déplace fichier.txt vers copie.txt
  • B. Elle renomme fichier.txt en copie.txt
  • C. Elle crée une copie de fichier.txt nommée copie.txt
  • D. Elle compare les deux fichiers

Correction publiée après la séance.

TP : commandes système sous Linux

Ce TP guide la découverte des commandes fondamentales d’un système Linux. Vous utiliserez le simulateur de terminal pour tester chaque commande (le simulateur Terminus présenté dans le cours sur les systèmes d’exploitation convient aussi). N’hésitez pas à expérimenter au-delà des exemples proposés.

Définition. Sous Linux, les fichiers et dossiers sont organisés en une structure hiérarchique appelée arborescence. La racine de cette arborescence est notée /. Chaque utilisateur dispose d’un répertoire personnel situé dans /home/.

Chemins absolus et relatifs. Un chemin absolu commence par / et décrit le trajet depuis la racine. Un chemin relatif décrit le trajet depuis le répertoire courant. Le symbole ~ désigne le répertoire personnel de l’utilisateur.

Exercice 1 : découvrir l’arborescence.

  1. Afficher le répertoire courant avec la commande pwd.

  2. Lister le contenu du répertoire courant avec ls.

  3. Se déplacer dans le répertoire /home avec cd /home, puis vérifier avec pwd.

  4. Revenir dans son répertoire personnel avec cd ~.

  5. Utiliser ls -la pour afficher les fichiers cachés. Que remarque-t-on ?

    Indice

    Comparer avec la sortie de ls : quels noms apparaissent en plus, et par quel caractère commencent-ils ? Que désignent les deux entrées . et .. ?

Correction publiée après la séance.

Exercice 2 : manipuler les chemins.

  1. Depuis son répertoire personnel, afficher le contenu de /etc sans s’y déplacer avec ls /etc.
  2. Créer un dossier projets avec mkdir projets.
  3. Se déplacer dans projets, puis créer un sous-dossier tp1 avec mkdir tp1.
  4. Revenir au répertoire parent avec cd .. et vérifier avec pwd.
  5. Afficher l’arborescence complète de projets avec tree projets.

Correction publiée après la séance.

Manipulation de fichiers et dossiers

Rappel. Les commandes de manipulation de fichiers sont destructives : une suppression avec rm est définitive (il n’y a pas de corbeille sous Linux). Soyez toujours prudent avant de supprimer un fichier ou un dossier.

Exercice 3 : créer et supprimer.

  1. Créer un fichier vide notes.txt avec touch notes.txt.

  2. Écrire du texte dedans avec echo "Ceci est un test" > notes.txt.

  3. Vérifier le contenu avec cat notes.txt.

  4. Ajouter une deuxième ligne avec echo "Deuxième ligne" >> notes.txt. Quelle est la différence entre > et >> ?

    Indice

    Afficher le fichier avec cat après chacune des deux commandes : la première ligne est-elle toujours là ?

  5. Copier le fichier avec cp notes.txt copie.txt, puis vérifier avec ls.

  6. Renommer copie.txt en sauvegarde.txt avec mv copie.txt sauvegarde.txt.

  7. Supprimer sauvegarde.txt avec rm sauvegarde.txt.

Correction publiée après la séance.

Exercice 4 : opérations sur les dossiers.

  1. Créer une arborescence en une seule commande avec mkdir -p cours/nsi/chapitre1.

  2. Vérifier le résultat avec tree cours.

  3. Créer un fichier cours/nsi/chapitre1/resume.txt avec un contenu de votre choix.

  4. Essayer de supprimer le dossier cours avec rm cours. Que se passe-t-il ?

  5. Utiliser rm -r cours pour supprimer le dossier et tout son contenu.

  6. Expliquer pourquoi l’option -r est nécessaire.

    Indice

    Que contient le dossier cours ? L’option -r signifie « récursif » : que faut-il supprimer avant de pouvoir supprimer un dossier ?

Correction publiée après la séance.

Traitement de texte

La philosophie Unix repose sur des outils simples qui font une seule chose bien, et que l’on combine avec le pipe (|) pour réaliser des traitements complexes. Le pipe transmet la sortie d’une commande comme entrée de la suivante.

Exercice 5 : filtrage et recherche.

Commencer par créer un fichier de données. La commande printf écrit le texte en remplaçant chaque \n par un retour à la ligne (la commande echo de Bash, elle, écrirait \n tel quel) :

printf "Alice 15\nBob 12\nCharlie 18\nDiana 15\nEve 12\nFrank 20\n" > eleves.txt

  1. Afficher les 3 premières lignes avec head -n 3 eleves.txt.

  2. Afficher les 2 dernières lignes avec tail -n 2 eleves.txt.

  3. Compter le nombre de lignes avec wc -l eleves.txt.

  4. Rechercher les élèves ayant 15 avec grep 15 eleves.txt.

  5. Trier le fichier par ordre alphabétique avec sort eleves.txt.

  6. Combiner les commandes : cat eleves.txt | sort | uniq. Expliquer le résultat.

    Indice

    Suivre les données d’une commande à l’autre : que reçoit sort, que reçoit uniq ? uniq ne retire que les lignes identiques qui se suivent : le fichier en contient-il ?

  7. Rechercher les lignes ne contenant pas « 15 » avec grep -v 15 eleves.txt.

Correction publiée après la séance.

Exercice 6 : pipes et enchaînements.

  1. Créer un fichier fruits.txt contenant : pomme, banane, cerise, pomme, banane, datte, pomme (une par ligne).

    Indice

    Reprendre la commande printf de l’exercice 5, avec un \n après chaque fruit.

  2. Compter le nombre d’occurrences de chaque fruit avec sort fruits.txt | uniq -c.

  3. Afficher uniquement les lignes contenant « an » avec grep an fruits.txt.

  4. Compter le nombre de lignes contenant « pomme » avec grep -c pomme fruits.txt.

  5. Rechercher récursivement le mot « test » dans tous les fichiers du répertoire courant avec grep -r test .

  6. Enchaîner deux commandes avec && : créer un dossier et s’y déplacer en une seule ligne.

    Indice

    L’opérateur s’écrit entre les deux commandes, commande1 && commande2 : la seconde ne s’exécute que si la première a réussi.

Correction publiée après la séance.

Permissions et utilisateurs

Définition. Chaque fichier possède trois catégories de permissions : lecture (r), écriture (w) et exécution (x), définies pour trois entités : le propriétaire (u), le groupe (g) et les autres (o). Ces permissions sont affichées sous la forme rwxrwxrwx ou en notation octale (par exemple 755).

Notation octale. Chaque chiffre représente les permissions d’une entité : r = 4, w = 2, x = 1. Par exemple, 755 signifie : propriétaire = 7 (rwx), groupe = 5 (r-x), autres = 5 (r-x).

Exercice 7 : gérer les permissions.

  1. Créer un fichier script.sh avec echo '#!/bin/bash' > script.sh (avec des guillemets doubles, Bash interpréterait le ! et afficherait une erreur).

  2. Afficher ses permissions avec ls -l script.sh. Les décrire.

    Indice

    Les dix premiers caractères se lisent ainsi : le type (- pour un fichier, d pour un dossier), puis trois groupes rwx, pour le propriétaire, le groupe et les autres ; un tiret signale une permission absente.

  3. Rendre le fichier exécutable pour le propriétaire avec chmod u+x script.sh.

  4. Vérifier le changement avec ls -l script.sh.

  5. Utiliser la notation octale pour donner les permissions rwxr-xr-- avec chmod 754 script.sh.

  6. Vérifier avec stat script.sh les informations détaillées du fichier.

Correction publiée après la séance.

Exercice 8 : utilisateurs et droits.

  1. Afficher son nom d’utilisateur avec whoami.

  2. Afficher ses identifiants avec id. Que représentent l’UID et le GID ?

  3. Essayer de passer en superutilisateur avec su root. Que se passe-t-il ?

  4. Utiliser sudo ls /root. Quelle est la différence entre su et sudo ?

    Indice

    Avec chacune des deux, combien de commandes s’exécutent avec les droits du superutilisateur : une seule, ou toute une session ?

Correction publiée après la séance.

Informations système

Exercice 9 : explorer le système.

  1. Afficher le nom de la machine avec hostname.

  2. Afficher les informations du système avec uname -a. Identifier le noyau et l’architecture.

  3. Afficher la date et l’heure avec date.

  4. Afficher l’utilisation du disque avec df -h. Que signifie l’option -h ?

    Indice

    Comparer avec la sortie de df sans l’option : en quelle unité les tailles sont-elles affichées dans chaque cas ?

  5. Afficher l’utilisation de la mémoire avec free -h.

Correction publiée après la séance.

Exercice 10 : historique et variables.

  1. Taper plusieurs commandes, puis afficher l’historique avec history.
  2. Afficher les variables d’environnement avec env. Identifier la variable HOME.
  3. Afficher la valeur de HOME avec echo $HOME.
  4. Créer une variable avec export MA_VAR=bonjour, puis l’afficher avec echo $MA_VAR.
  5. Créer un alias avec alias ll="ls -la", puis le tester.

Correction publiée après la séance.

Recherche de fichiers

Exercice 11 : trouver et identifier.

  1. Créer l’arborescence suivante :

    mkdir -p projet/src projet/docs projet/tests
touch projet/src/main.py projet/src/utils.py
touch projet/docs/readme.txt projet/tests/test_main.py

  2. Rechercher tous les fichiers Python avec find projet -name "*.py".

    Indice

    Dans le motif "*.py", l’étoile remplace n’importe quelle suite de caractères : quels noms de fichiers ce motif désigne-t-il ?

  3. Rechercher uniquement les dossiers avec find projet -type d.

  4. Identifier le type du fichier projet/src/main.py avec file projet/src/main.py.

  5. Vérifier l’emplacement de la commande ls avec which ls.

  6. Consulter le manuel de la commande grep avec man grep.

Correction publiée après la séance.

Commandes essentielles à retenir

  • Navigation : pwd, cd, ls, tree ;
  • Fichiers : touch, cp, mv, rm, mkdir, cat, echo ;
  • Texte : head, tail, wc, grep, sort, uniq ;
  • Permissions : chmod, ls -l, whoami, id, sudo ;
  • Système : uname, hostname, date, df, free, history ;
  • Recherche : find, file, which, man ;
  • Opérateurs : > (redirection), >> (ajout), | (pipe), && (enchaînement).

31 - Adressage IP 33 - Algorithmes gloutons