34 - Systèmes (Shell)

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

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

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

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

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.

Navigation dans l’arborescence

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 ?

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.

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 >> ?
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.

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.

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 :

echo "Alice 15\nBob 12\nCharlie 18\nDiana 15\nEve 12\nFrank 20" > 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.
7. Rechercher les lignes ne contenant pas « 15 » avec grep -v 15 eleves.txt.

Exercice 6 : pipes et enchaînements.

1. Créer un fichier fruits.txt contenant : pomme, banane, cerise, pomme, banane, datte, pomme (une par ligne).
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.

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.
2. Afficher ses permissions avec ls -l script.sh. Les décrire.
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.

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 ?

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 ?
5. Afficher l’utilisation de la mémoire avec free -h.

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.

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".

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.

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).