class: center, middle # TP : Linux --- <!-- class: hljs-rainbow --> # Exercice 1 : Chemins relatifs et absolus 1°) En vous basant sur cette arborescence Linux (simplifiée), déterminez les chemins absolus des fichiers `cp` ; `vlc` ; `liste.odt`. <!-- espace énorme autour du graphique -> position absolue --> <div style="width: 80%;position: absolute; top: 200px;"> <div class="mermaid"> graph TD; linkStyle default interpolate basis rac["/"]--> bin[bin] --> bash([bash]) rac--> boot[boot] & etc[etc] & home[home] & lib[lib] & media[media] & root[root] & usr[usr] usr-->bin2[bin]--> firefox([firefox]) home--> bob[bob]--> documents[documents]--> photos[photos]--> photo([IMG1642.jpg]) documents--> textes[textes]--> texte([liste.odt]) home--> alice[alice]--> travail[travail]--> scripts[scripts]--> script([toto.py]) travail--> fiche([synthese.pdf]) media--> usb[usb] bin--> cd([cd]) & cp([cp]) bin2--> libre[libreoffice] & vlc[vlc] classDef dossier fill:#00BFFF,stroke:#333 classDef racine fill:#f96,stroke:#333 classDef fichier fill:#9f6,stroke:#333 class rac racine class mnt,bin,usr,bin2,boot,root,home,lib,etc,media,bob,alice,usb,images,documents,photos,travail,scripts,textes dossier class cd,cp,bash,script,fiche,photo,texte,firefox,vlc,libre fichier </div> </div> --- <div style="width: 80%;position: absolute; top: 150px;"> <div class="mermaid"> graph TD linkStyle default interpolate basis rac["/"]--> bin[bin] --> bash([bash]) rac--> boot[boot] & etc[etc] & home[home] & lib[lib] & media[media] & root[root] & usr[usr] usr-->bin2[bin]--> firefox([firefox]) home--> bob[bob]--> documents[documents]--> photos[photos]--> photo([IMG1642.jpg]) documents--> textes[textes]--> texte([liste.odt]) home--> alice[alice]--> travail[travail]--> scripts[scripts]--> script([toto.py]) travail--> fiche([synthese.pdf]) media--> usb[usb] bin--> cd([cd]) & cp([cp]) bin2--> libre[libreoffice] & vlc[vlc] classDef dossier fill:#00BFFF,stroke:#333 classDef racines fill:#f96,stroke:#333 classDef fichier fill:#9f6,stroke:#333 class rac racines class mnt,bin,usr,bin2,boot,root,home,lib,etc,media,bob,alice,usb,images,documents,photos,travail,scripts,textes dossier class cd,cp,bash,script,fiche,photo,texte,firefox,vlc,libre fichier </div> </div> 2°) (Appuyez sur F5). Toujours en vous basant sur cette même arborescence, déterminez le chemin relatif permettant d'accéder aux fichiers : * `synthese.pdf` depuis le répertoire `alice` ; * `synthese.pdf` depuis le répertoire `scripts` ; * `IMG1642.jpg` depuis le répertoire `textes` ; * `liste.odt` depuis le répertoire `scripts`. --- # Exercice 2 : Commandes de base Ouvrez un _terminal_ avec le raccourci Ctrl Alt t (ou en cherchant dans le menu de Xubuntu). Vous avez maintenant accès à une invite de commandes de Linux, ou _shell_ qui permet d'interagir avec le système Linux pour, par exemple, créer des dossiers ou des fichiers. Le symbole `$` représente le prompt du shell : il ne fait pas partie des commandes. Deux touches seront très utiles dans le terminal : * la touche `TAB`, très pratique pour compléter les noms de commandes ou de fichiers ; * la touche `↑`, qui permet de rappeler une commande précédente pour (la modifier puis) la ré-exécuter. --- 1°) Naviguer et se repèrer dans l'arborescence. Une arborescence est constituée de dossiers (répertoires) contenant d'autres dossiers ou des fichiers. Commençons par voir à quel emplacement de l'arborescence nous sommes, pour cela utilisez la commande `pwd` (_print working directory_) : ```bash $ pwd ``` La commande `pwd` vous renvoie toujours le chemin absolu du répertoire courant. Sous Linux, les dossiers personnels des utilisateurs sont des sous-dossiers du dossier `home`. Déplacez-vous dans ce répertoire `home` à l'aide d'un chemin absolu : ```bash $ cd /home ``` La commande `cd` (_change directory_) est suivie du chemin vers le répertoire spécifié (n'oubliez pas **l'espace entre la commande et le paramètre**). --- Dans la suite remplacez `toto` par votre nom d'utilisateur. Retournez maintenant dans votre répertoire personnel, il suffit de taper une des commandes : * sous forme de chemin absolu : ```bash $ cd /home/toto ``` (ou éventuellement quelque chose comme `cd /home/pg1/toto`) * avec `~`, qui désigne le répertoire personnel de l'utilisateur actif : ```bash $ cd ~ ``` * ou encore, puisque vous êtiez déjà dans `/home`, avec un chemin relatif (`.` désigne le répertoire actuel donc actuellement `/home`) : ```bash $ cd ./toto ``` (ou éventuellement quelque chose comme `cd ./pg1/toto`) --- 2°) Créer des répertoires avec la commande `mkdir` (_make directory_) * Une fois dans votre répertoire personnel vous pouvez créer un répertoire nommé `tp_linux` : ```bash $ mkdir tp_linux ``` * Pour créer, dans `tp_linux`, 5 répertoires enfants nommés `rep1` , `rep2`, `rep3`, `rep4` et `rep5` : ```bash $ cd tp_linux $ mkdir rep1 rep2 rep3 rep4 rep5 ``` --- 3°) Afficher le contenu d'un répertoire avec la commande `ls` (_list_) En se plaçant toujours dans le répertoire `tp_linux` tapez : ```bash $ ls ``` Pour afficher le contenu d'un répertoire autre que le répertoire courant, vous pouvez ajouter le nom de ce dossier après `ls`, par exemple : ```bash $ ls /home/toto ``` --- 4°) Supprimer des répertoires avec la commande `rmdir` (_remove directory_, il faut que le dossier soit vide). Pour supprimer `rep5` depuis le dossier `tp_linux`, rien de plus simple : ```bash $ rmdir rep5 ``` Toutes les commandes précédentes peuvent être effectuées avec des chemins relatifs (comme les exemples précédents) ou des chemins absolus. Supprimons le répertoire `rep4` avec un chemin absolu : ```bash $ rmdir ~/tp_linux/rep4 ``` Supprimons le répertoire `rep3` avec un chemin relatif (ici à partir du dossier utilisateur) : ```bash $ cd ~ $ rmdir tp_linux/rep3 ``` --- 5°) Créer des fichiers vides avec la commande `touch` * Crééons un fichier vide nommé `essai1` dans `rep1` (sous Unix les fichiers n'ont pas nécessairement une extension) : ```bash $ touch /home/toto/tp_linux/rep1/essai1 ``` Constatez qu'il n'est pas nécessaire de se placer dans le dossier pour créer le fichier, nous avons ici utilisé un chemin absolu. Vous pouvez vérifier ce qui c'est passé sans vous déplacer dans le répertoire `rep1` : ```bash $ ls ~/tp_linux/rep1 essai1 ``` * On peut également créer plusieurs fichiers simultanément. Par exemple : créons les fichiers `essai2a` et `essai2b` dans `rep2` ```bash $ cd tp_linux $ touch rep2/essai2a rep2/essai2b ``` --- À ce stade il est bon de vérifier notre travail, normalement la structure du dossier `tp_linux` doit être la suivante : ``` . ├── rep1 │ └── essai1 └── rep2 ├── essai2a └── essai2b ``` Une commande permet d'ailleurs d'afficher l'arborescence partant du répertoire courant : ```bash $ tree ``` _Remarques:_ remarquez au sommet le symbole `.` représentant le répertoire courant, ici `tp_linux`, qui contient deux répertoires `rep1` et `rep2` ; le premier contenant le fichier `essai1` et le second deux fichiers `essai2a` et `essai2b`. * Entrez dans le dossier `rep1` et vérifiez son contenu. * En une seule commande, remontez au dossier parent puis entrez dans `rep2`. Vérifiez son contenu. --- 6°) Supprimer des fichiers avec la commande `rm` (_remove_) Pour supprimer le fichier `essai2a` depuis le répertoire `rep2` puis vérifier le contenu du répertoire : ```bash $ cd rep2 $ rm essai2a $ ls ``` A ce stade la structure du dossier `tp_linux` doit être la suivante : ``` . ├── rep1 │ └── essai1 └── rep2 └── essai2b ``` --- 7°) Renommer (ou déplacer) un fichier avec la commande `mv` (_move_) * __Déplaçons__ le fichier `essai2b` restant vers le répertoire en `rep1`. ```bash $ mv essai2b ../rep1/ ``` Cette commande accepte deux paramètres : le premier correspond au chemin vers le fichier d'origine, ici `essai2b`, le second au nouvel emplacement du fichier après déplacement ici `../rep1/` __Attention : ici le `/` final est important__ : il indique qu'on déplace le fichier dans un répertoire : le fichier serait sinon renommé. A ce stade voilà l'arborescence du dossier `tp_linux` : ``` . ├── rep1 │ ├── essai1 │ └── essai2b └── rep2 ``` --- * La commande `mv` permet également de __renommer__ un fichier (en le déplaçant ou non). Rendez-vous dans `rep1` puis tapez : ```bash $ mv essai2b essai1b ``` (remarquez l'absence de `/` après `essai1b` : il ne s'agit pas d'un répertoire). La structure devient alors : ``` . ├── rep1 │ ├── essai1 │ └── essai1b └── rep2 ``` _Remarque :_ on aurait pu réaliser les 2 étapes précédentes en une seule commande depuis le répertoire d'origine du fichier : `mv essai2b ../rep1/essai1b` (déplacement et renommage du fichier) --- 8°) Copier un fichier avec la commande `cp` (_copy_) Au lieu de déplacer le fichier on peut aussi vouloir en faire une copie (en la renommant). A partir de `rep1`, copions `essai1b` dans `rep2` en nommant la copie `essai2_new` ```bash $ cp essai1b ../rep2/essai2_new ``` Comme la commande `mv`, la commande `cp` accepte deux paramètres : le premier correspond au chemin du fichier d'origine le second au chemin vers la copie. Pensez à naviguer entre les répertoires avec `cd`, vérifiez quel est le répertoire courant avec `pwd` et lister le contenu des répertoires avec `ls`. Au final la structure du dossier `tp_linux` doit être la suivante : ``` . ├── rep1 │ ├── essai1 │ └── essai1b └── rep2 └── essai2_new ``` --- 9°) Récupération d'un fichier archive depuis Internet * Téléchargez un fichier vers le dossier courant : ```bash $ wget clogique.fr/nsi/premiere/td_tp/archive_linux.tar ``` (il est possible que le proxy du lycée bloque cette commande ; dans ce cas, tapez l'adresse _clogique.fr/nsi/premiere/td_tp/archive_linux.tar_ directement dans le navigateur, l'archive se retrouvera dans le dossier _Téléchargements_) * Ah, en fait je me suis trompé, je ne voulais pas que cette archive soit dans ce dossier. Créez un sous-dossier de _tp_linux_ appelé _arbo_, déplacez le fichier _archive_linux.tar_ dedans puis déplacez-vous dedans. * Tapez : ```bash $ tar -xvf archive_linux.tar ``` pour extraire les dossiers et les fichiers de l'archive. * Supprimez le fichier _archive_linux.tar_. * Enfin, affichez le contenu du sous dossier Compagnon/A32. --- 10°) Afficher le contenu d'un fichier ou écrire dans un fichier * La commande `cat` (*concatenate*) permet d'afficher ou de modifier le contenu d'un fichier. ```bash $ cat Compagnon/A13/Documents/liste-etudiant.txt ``` Remarque : la commande `more` (à la place de `cat`) permet d'afficher progressivement les données (Ctrl c pour quitter). * La commande `cat` permet aussi d'écrire dans un fichier, en utilisant l’opérateur de redirection > : ```bash $ cat > coucou.txt ``` le fichier est créé et vous pouvez commencer à le remplir avec du texte ; appuyez sur _Entrée_ pour créer une nouvelle ligne et sur _Ctrl d_ quand vous aurez fini puis affichez le contenu de votre fichier avec `cat coucou.txt`. * Pour ajouter du texte dans votre fichier, il faudra utiliser : ```bash $ cat >> coucou.txt ``` --- * `cat` permet enfin de *concaténer* des fichiers (d'où son nom) : ```bash $ cp coucou.txt coucou2 $ cat coucou.txt coucou2 > fusion $ cat fusion ``` * La commande `echo` envoie son paramètre vers la sortie courante (par défaut, l'écran) : ```bash $ echo 'Bonjour' ``` * Nous pouvons rediriger la sortie de cette commande vers un fichier afin d'écrire dedans (ceci créera le fichier s'il n'existe pas et remplacera son contenu sinon) : ```bash $ echo 'Bonjour' > toto.txt $ cat toto.txt ``` --- 11°) Créer et exécuter un script shell Les administrateurs systèmes ne tapent bien sûr pas toutes ces commandes à chaque intervention mais les stockent dans des fichiers scripts bash (il est d'usage de leur donner comme extension `.sh`). Les commandes du shell correspondent à des fichiers placés pour la plupart dans le dossier `/bin`. Tapez : ```bash $ ls /bin ``` et reconnaissez quelques commandes shell déjà vues. Nous pouvons directement exécuter ces commandes car leur chemin est dans une variable d'environnement appelée _PATH_ : ```bash $ echo $PATH ``` --- Créons maintenant un fichier de commandes shell : ```bash $ cat > monscript.sh ``` tapez dedans les commandes : ```bash #!/bin/bash cd / tree -L 1 ``` et fermez le fichier avec _Ctrl d_. Remarques : * la première ligne indique le nom de l'interpréteur (bash) puis le script doit remonter à la racine et afficher tous ses dossiers enfants (enlever `-L 1` pour avoir l'arborescence complète) * le langage shell est un vrai langage de programmation, qui comporte des instructions conditionnelles, des boucles etc. ([voir ici par exemple](http://doc.ubuntu-fr.org/tutoriel/script_shell)). --- Pour exécuter notre script, nous devons : * lui donner des droits d'exécution : ```bash $ chmod +x monscript.sh ``` * essayez maintenant de lancer notre script en tapant son nom (son chemin relatif ou absolu) : ```bash $ monscript.sh ``` * en fait notre fichier n'est pas dans un des dossiers listé dans le PATH, il faut préciser son chemin relatif ou absolu : ```bash $ ./monscript.sh ``` (ici nous précisons qu'il est dans le dossier courant). --- # Exercice 3 : Droits des fichiers Les fichiers et dossiers ont des droits en lecture, en écriture et en exécution (pour les fichiers seulement !). Ces droits s'appliquent à des utilisateurs ou à des groupes d'utilisateurs et à tout le monde. Pour connaître le nom de votre utilisateur, tapez : ```bash $ whoami ``` Pour savoir dans quels groupes il est, tapez : ```bash $ groups ``` --- En tant qu'utilisateur normal, vous ne pouvez pas tout faire, essayez par exemple de supprimer la commande shell `pwd` : ```bash $ rm /bin/pwd ``` Pour comprendre pourquoi, affichons les droits des dossiers présents à la racine du système Linux (essayez aussi sans l'option `-l`) : ```bash $ ls -l / ``` Observons la ligne : `drwxrwxr-x 1 root root ......... bin` : * le nom du fichier ou du dossier est à la fin , ici `bin` ; * le nom de l'utilisateur et son groupe sont au milieu : ici `root` et `root` ; * le premier caractère est un `d`, ce qui signifie que `bin` est un dossier ; * puis apparaissent les droits, par paquets de 3 caractères : * `rwx` veut dire que l'utilisateur `root` a un droit en lecture (read : lister le contenu des dossiers ou des fichiers), en écriture (write) et en accès (x pour accès ou exécution dans le cas d'un fichier) ; * `rwx` veut dire que les membres du groupe `root` ont tous les accès ; * `r-x` veut dire que les autres ont un droit en lecture mais pas en écriture et en accès (x pour accès ou exécution dans le cas d'un fichier). --- La ligne `drwxr-xr-x 4 root root ........... boot` nous montre que l'utilisateur root a tous les accès sur le dossier `/boot` mais que le groupe `root` et l'utilisateur commun n'ont pas d'accès en écriture. Depuis le dossier _arbo_, faîtes afficher les dossiers et fichiers et leurs droits. Vous verrez par exemple que : * `Compagnon` est un dossier qui appartient à l'utiliseur courant (vous !), dont le groupe porte le même nom et que seul l'utilisateur peut écrire dedans ; * `mon_script.sh` est un fichier exécutable par tous (en fait tout ceux qui ont accès au dossier courant...) mais modifiable seulement par l'utilisateur courant ; * `toto.txt` est un fichier lisible par tous mais modifiable seulement par l'utilisateur courant et son groupe. --- Il est possible de changer les droits avec la commande `chmod`, en attribuant (+) ou en retirant (-) des droits, soit à l'utilisateur (u), soit au groupe (g), soit aux autres (o pour others), soit à tous (a pour all). Par exemple, pour modifier les droits du fichier `toto.txt` (pensez à faire `ls -l` pour constater les modifications) : ```bash $ chmod g-w toto.txt ``` pour retirer un droit en écriture au groupe ; ```bash $ chmod u+x toto.txt ``` pour donner un droit d'exécution à l'utilisateur ; ```bash $ chmod o-r toto.txt ``` pour retirer le droit de lecture aux autres (o = others). --- Concernant les dossiers : ```bash $ chmod u-x Compagnon ``` pour retirer l'accès au dossier `Compagnon` pour l'utilisateur (essayez `cd Compagnon` maintenant...) ```bash $ chmod u+x-r Compagnon ``` pour rendre l'accès au dossier `Compagnon` à l'utilisateur mais en lui retirant le droit de lecture (essayez `cd Compagnon` puis `ls`...). Remarque : le droit `x` sert à l'exécution pour les fichiers mais aussi à permettre l'entrée dans un dossier ! --- Nous pouvons aussi utiliser la notation octale, par exemple : * r-- correspond au nombre binaire 100 donc au nombre entier 4 ; * rw- correspond au nombre binaire 110 donc au nombre entier 6 ; * rwx correspond au nombre binaire 111 donc au nombre entier 7 ; * donc les droits rwxrw-r-- s'écrivent aussi 764. Ainsi : ```bash $ chmod 764 toto.txt ``` va attribuer tous les droits à l'utilisateur ; la lecture et l'écriture au groupe et seulement la lecture aux autres. Remarque : avec cette méthode, nous pouvons choisir rapidement des droits, mais pas en ajouter ou en retirer. Donnez tous les droits possibles au fichier `toto.txt`. --- exclude: true # Série d'exercices d'application Vous allez maintenant avoir accès à une série d'exercices envoyés puis vérifiés par le poste professeur. Vous accéderez à chacun des exercices depuis le terminal avec la commande (remplacez IP_SERVEUR par l'adresse IP que le professeur vous a donné) : ```bash $ curl IP_SERVEUR:8080 ``` --- # Exercice 4 : À vous de jouer __Pour chacune des étapes suivantes écrivez les commandes associées et réalisez-les.__ Il est fortement conseillé de dessiner sur un brouillon au fur et à mesure l'arborescence : cela vous aidera à vous repérer. Cette dernière sera demandée à quelques points d'étapes. __1)__ Placez-vous dans votre répertoire personnel __2)__ Depuis votre répertoire personnel : * __a-__ Créez un répertoire `data` * __b-__ Créez deux répertoires enfants au répertoire `data` nommés `travail` et `maison` * __c-__ Créez les fichiers `agenda`, `collegues`, `cuisine` dans `travail` __3)__ Placez-vous dans le répertoire `travail` --- __4)__ Depuis `travail` * __a-__ Listez le contenu du répertoire * __b-__ Dupliquez le fichier `agenda` en nommant le nouveau `agenda2` * __c-__ Déplacez `cuisine` dans le répertoire `maison` (le nom ne sera pas modifié) * __d-__ Supprimez le fichier `agenda2` __5)__ Dessinez la structure du répertoire `data` __6)__ Placez-vous dans le répertoire `maison` __7)__ Depuis le répertoire `maison` : * __a-__ Créez 3 répertoires endants de `maison` nommés `videos`, `info` et` musique` * __b-__ Créez 4 répertoires enfants de `musique` nommés `rnb`, `jazz`, `rock` et `rap` __8)__ Déplacez vous en une seule commande dans le répertoire `rap` __9)__ Depuis le répertoire `rap` supprimez le répertoire `rock` __10)__ Dessinez la structure du répertoire `data` __11)__ Déplacez-vous en une seule commande dans le répertoire `travail` __11)__ Empèchez l'accès au dossier `travail` à tout autre utilisateur que vous-même. --- Bibliographie : * https://gitlab.com/gprano/serveur-exos-zip/-/tree/main/ pour le serveur d'exercices * https://framagit.org/patth/nsi_1ere/-/blob/master/docs/4_os/partie1/tp_shell/tp_shell.md * https://pixees.fr/informatiquelycee/n_site/nsi_prem_cmd_base_linux.html * http://www.icour.fr/a/fichiers/1/files/NSI%20Premi%C3%A8re/129/TDshell.pdf