TP : Linux

class: center, middle

# TP : Linux

---

# Exercice 1 : Chemins relatifs et absolus
<p>Voici une arborescence Linux (simplifiée) :</p>

<div style="width: 80%;position: absolute; top: 90px;">
<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: 510px;">
1°) En vous basant sur celle-ci, déterminez les chemins absolus des fichiers 
`cp` ; `vlc` ; `liste.odt`.
</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
Dans la suite, le symbole `$` représentera le prompt du shell : il ne fait pas partie de la commande.
N'oubliez pas d'utiliser la touche `TAB`, très pratique pour compléter les noms de commandes ou de fichiers.

Ouvrez [ce site](http://weblinux.univ-reunion.fr/) dans un nouvel onglet avec un Ctrl-Clic (conseil : n'utilisez pas le bouton "Sauvegarder le dossier d'Alice", qui risque de bloquer la page...).

---

1°) Naviguer et se repèrer dans l'arborescence.
Commencez par vous placer dans le répertoire `home` à l'aide d'un chemin absolu :
```bash
$ cd /home
```

La commande `cd` est suivie d'un paramètre qui est ici le chemin vers le répertoire spécifié (n'oubliez pas **l'espace entre la commande et le paramètre**).

Vous pouvez vérifier à tout moment où vous êtes en utilisant la commande `pwd` (*print working directory*) :
```bash
$ pwd
```

La commande `pwd` vous renvoie toujours le chemin absolu du répertoire courant.

---
Placez-vous maintenant dans votre répertoire personnel : c'est par défaut un des répertoires enfants de `home`. Ici, votre nom d'utilisateur est `alice`, il suffit de taper une des commandes :
* sous forme de chemin absolu :
```bash
$ cd /home/alice
```
* avec `~`, qui désigne le répertoire personnel de l'utilisateur actif :
```bash
$ cd ~
```
* ou encore, avec un chemin relatif depuis `/home` par exemple (`.` désigne le répertoire actuel) :
```bash
$ cd ./alice
```

---

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 de travail nommé `nsi` :

```bash
$ mkdir nsi
```

* Pour créer, dans `nsi`, 5 répertoires enfants nommés `rep1` , `rep2`, `rep3`, `rep4` et `rep5` :

```bash
$ cd nsi
$ 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 `nsi` 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/alice
```

---

4°) Supprimer des répertoires avec la commande `rmdir` (_remove directory_)
Pour supprimer `rep5` depuis le répertoire `nsi`, 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 ~/nsi/rep4
```

Supprimons le répertoire `rep3` avec un chemin relatif (ici à partir du dossier utilisateur) :
```bash
$ cd ~
$ rmdir ./nsi/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/alice/nsi/rep1/essai1
```

Constatez qu'il n'est pas nécessaire de se placer dans le dossier pour créer le fichier, on a ici utilisé un chemin absolu.

On peut vérifier ce qui c'est passé sans se déplacer dans le répertoire `rep1`  !!

```bash
$ ls ~/nsi/rep1
essai1
```

* On peut également créer plusieurs fichiers simultanément. Par exemple : créons les fichiers `essai2a` et `essai2b` dans `rep2`

```bash
$ cd nsi
$ touch rep2/essai2a rep2/essai2b
```

---

A ce stade il est bon de vérifier notre travail, normalement la structure du dossier `nsi` 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 `nsi`, 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 `nsi` 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 `nsi` :

```
.
├── 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 `nsi` doit être la suivante :

```
.
├── rep1
│   ├── essai1
│   └── essai1b
└── rep2
    └── essai2_new
```

---

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

* 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+Z (normalement c'est Ctrl-D mais cela est associé à autre chose dans le navigateur) 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
```

---

10°) 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
$ echo '#!/bin/bash' > monscript.sh
$ echo 'cd /' >> monscript.sh
$ echo 'tree -L 1' >> monscript.sh
```

Remarques : 
* j'utilise `echo` car nous ne pouvons pas fermer correctement le fichier en utilisant `cat` du fait de l'absence de Ctrl-D ;
* 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
```
* le lancer en tapant son nom ; comme il n'est pas dans le PATH, il faut préciser son chemin relatif ou absolu :
```bash
$ ./monscript.sh
```

---

# 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 liés au dossier `/bin` (essayez aussi sans l'option `-l`) :
```bash
$ ls -l /
```

Observons la première ligne : `drwxrwxr-x    1 root     root          2675 Feb 26 09:25 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 deuxième ligne `drwxr-xr-x   7    root    root    2200 Feb 26 09:26 dev` nous montre que le dossier `/dev` a les mêmes droits que `/bin`, sauf qu'il n'est pas accessible en écriture pour le groupe `root`.

Allez dans le dossier utilisateur d'`alice` et affichez son contenu :
<div style="text-align: center;">
<img src="../img/droits.png" alt="droits" width="600px">
</div>

Nous voyons par exemple que :
* `Compagnon` est un dossier qui appartient à `alice`, du groupe `user` et que seule celle-ci 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 `alice` ;
* `toto.txt` est un fichier lisible par tous mais modifiable seulement par `alice`.

---

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

---

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

---

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

---

# Exercice 4 : A 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.

---
Sources de ce document :
* 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