Partie 3 : Systèmes d'exploitation

B.O. spécial n° 1 du 22 janvier 2019 - NSI Première

Contenus	Capacités attendues	Commentaires
Systèmes d'exploitation.	Identifier les fonctions d'un système d'exploitation. Utiliser les commandes de base en ligne de commande. Gérer les droits et permissions d'accès aux fichiers.	Les éléments du programme concernent les systèmes de type UNIX (Linux).

1. Qu'est-ce qu'un système d'exploitation ?

1.1 Définition

Un système d'exploitation (SE, ou Operating System - OS) est un logiciel qui sert d'intermédiaire entre le matériel (processeur, mémoire, disque, écran...) et les applications (navigateur, traitement de texte, jeux...).

┌──────────────────────────────────┐
│        Applications              │
│  (navigateur, Python, jeux...)   │
├──────────────────────────────────┤
│     Système d'exploitation       │
│  (Linux, Windows, macOS...)      │
├──────────────────────────────────┤
│          Matériel                │
│  (processeur, RAM, disque...)    │
└──────────────────────────────────┘

1.2 Les fonctions principales

Le système d'exploitation assure cinq fonctions essentielles :

Fonction	Description
Gestion des processus	Lancer, suspendre, arrêter des programmes ; partager le processeur entre eux
Gestion de la mémoire	Attribuer de la mémoire aux programmes, la libérer quand ils se terminent
Gestion des fichiers	Organiser les données sur le disque (répertoires, fichiers, droits)
Gestion des entrées/sorties	Communiquer avec les périphériques (clavier, écran, réseau, USB...)
Interface utilisateur	Fournir une interface graphique (GUI) ou en ligne de commande (CLI)

1.3 Les principaux systèmes d'exploitation

Système	Créateur	Type	Usage principal
Linux	Linus Torvalds (1991)	Libre (open source)	Serveurs, développement, embarqué
Windows	Microsoft (1985)	Propriétaire	Bureautique, jeux
macOS	Apple (2001)	Propriétaire (base UNIX)	Créatif, développement
Android	Google (2008)	Libre (basé sur Linux)	Smartphones
iOS	Apple (2007)	Propriétaire	Smartphones Apple

2. Le système de fichiers

2.1 Organisation hiérarchique

Les fichiers sont organisés dans une structure arborescente (un arbre) :

/ (racine)
├── home/
│   ├── alice/
│   │   ├── Documents/
│   │   │   └── cours.txt
│   │   ├── Images/
│   │   └── .bashrc
│   └── bob/
│       └── projet/
├── etc/
├── var/
├── tmp/
└── usr/

Élément	Description
`/`	Répertoire racine (sommet de l'arbre)
`/home/alice/`	Répertoire personnel de l'utilisateur Alice
`~`	Raccourci vers le répertoire personnel de l'utilisateur courant
`.`	Répertoire courant
`..`	Répertoire parent

2.2 Chemin absolu et chemin relatif

Il existe deux façons de désigner un fichier :

Type	Définition	Exemple
Chemin absolu	Part de la racine `/`	`/home/alice/Documents/cours.txt`
Chemin relatif	Part du répertoire courant	`Documents/cours.txt` (si on est dans `/home/alice/`)

# Analogie Python
# Chemin absolu : l'adresse complète
"/home/alice/Documents/cours.txt"

# Chemin relatif : depuis où on est
"Documents/cours.txt"         # dans /home/alice/
"../bob/projet/"              # remonter d'un niveau, aller dans bob/projet

3. Commandes de base en ligne de commande

3.1 Le terminal

Le terminal (ou shell) est une interface en ligne de commande qui permet d'interagir avec le système d'exploitation en tapant des commandes textuelles.

Le caractère > (ou $) est l'invite de commande (prompt) : il indique que le terminal attend une commande.

Commande	Signification	Exemple
`pwd`	Afficher le répertoire courant (Print Working Directory)	`> pwd` → `/home/alice`
`ls`	Lister le contenu d'un répertoire (List)	`> ls` → `Documents Images .bashrc`
`ls -l`	Liste détaillée (droits, taille, date)
`cd rep`	Changer de répertoire (Change Directory)	`> cd Documents`
`cd ..`	Remonter au répertoire parent	`> cd ..`
`cd ~`	Retourner au répertoire personnel	`> cd ~`
`cd /`	Aller à la racine	`> cd /`

3.3 Manipulation de fichiers et répertoires

Commande	Action	Exemple
`mkdir nom`	Créer un répertoire (Make Directory)	`> mkdir Projets`
`rmdir nom`	Supprimer un répertoire vide	`> rmdir Projets`
`touch nom`	Créer un fichier vide	`> touch notes.txt`
`cp source dest`	Copier un fichier (Copy)	`> cp notes.txt copie.txt`
`mv source dest`	Déplacer ou renommer (Move)	`> mv notes.txt Documents/`
`rm nom`	Supprimer un fichier (Remove)	`> rm copie.txt`
`cat nom`	Afficher le contenu d'un fichier	`> cat notes.txt`
`less nom`	Afficher page par page	`> less notes.txt`

3.4 Exemple de session

> pwd
/home/alice
> ls
Documents  Images  .bashrc
> mkdir Projets
> cd Projets
> pwd
/home/alice/Projets
> touch hello.py
> ls
hello.py
> cp hello.py hello_backup.py
> ls
hello.py  hello_backup.py
> cd ..
> pwd
/home/alice

4. Les droits d'accès

4.1 Utilisateurs et groupes

Sous UNIX, chaque fichier appartient à un utilisateur (le propriétaire) et à un groupe. Les droits d'accès sont définis pour trois catégories :

Catégorie	Symbole	Description
Propriétaire	`u`	L'utilisateur qui possède le fichier
Groupe	`g`	Les membres du groupe du fichier
Autres	`o`	Tous les autres utilisateurs

4.2 Les trois types de droits

Droit	Lettre	Valeur	Sur un fichier	Sur un répertoire
Lecture	`r`	4	Lire le contenu	Lister le contenu (`ls`)
Écriture	`w`	2	Modifier le contenu	Ajouter/supprimer des fichiers
Exécution	`x`	1	Exécuter le programme	Traverser (`cd`)

4.3 Afficher les droits

La commande ls -l affiche les droits de chaque fichier :

> ls -l
-rw-r--r--  1 alice  staff  1234  juil. 7 10:30  cours.txt
drwxr-x---  2 alice  staff    64  juil. 7 10:30  Documents

Décomposition de -rw-r--r-- :

 -    rw-    r--    r--
 │    │      │      │
 │    │      │      └── Autres : lecture seule
 │    │      └──────── Groupe : lecture seule
 │    └─────────────── Propriétaire : lecture + écriture
 └──────────────────── Type (- = fichier, d = répertoire)

4.4 Modifier les droits : `chmod`

La commande chmod (change mode) modifie les droits d'accès.

Notation symbolique

> chmod u+x script.py       # ajouter l'exécution pour le propriétaire
> chmod g-w fichier.txt     # retirer l'écriture pour le groupe
> chmod o-r secret.txt      # retirer la lecture pour les autres
> chmod a+r public.txt      # ajouter la lecture pour tout le monde

Symbole	Signification
`u`, `g`, `o`, `a`	Propriétaire, groupe, autres, tous
`+`, `-`	Ajouter, retirer un droit
`r`, `w`, `x`	Lecture, écriture, exécution

Notation numérique (octale)

On additionne les valeurs des droits pour chaque catégorie :

Droits	Calcul	Valeur
`rwx`	4 + 2 + 1	7
`rw-`	4 + 2 + 0	6
`r-x`	4 + 0 + 1	5
`r--`	4 + 0 + 0	4
`---`	0 + 0 + 0	0

> chmod 755 script.py     # rwxr-xr-x (proprio: tout, groupe/autres: lecture+exécution)
> chmod 644 fichier.txt   # rw-r--r-- (proprio: lire+écrire, groupe/autres: lire)
> chmod 700 secret.txt    # rwx------ (proprio uniquement)

5. Les processus

5.1 Définition

Un processus est un programme en cours d'exécution. Quand on lance un programme, le système d'exploitation crée un processus qui contient :

Le code du programme en mémoire
Les données qu'il manipule
Un identifiant unique appelé PID (Process Identifier)

5.2 Commandes liées aux processus

Commande	Rôle
`ps`	Lister les processus de l'utilisateur
`ps aux`	Lister tous les processus du système
`top`	Afficher les processus en temps réel (`Ctrl`+`C` pour quitter)
`kill PID`	Terminer un processus par son PID

> ps
  PID TTY          TIME CMD
 1234 pts/0    00:00:00 bash
 5678 pts/0    00:00:02 python3
 5679 pts/0    00:00:00 ps

5.3 Multi-tâches

Les systèmes d'exploitation modernes sont multi-tâches : ils donnent l'impression que plusieurs programmes s'exécutent en même temps. En réalité, le processeur alterne très rapidement entre les processus (plusieurs milliers de fois par seconde). L'ordonnanceur (scheduler) du SE décide quel processus obtient le processeur à chaque instant.

À retenir

Le système d'exploitation est l'intermédiaire entre le matériel et les applications.
Ses fonctions : gestion des processus, de la mémoire, des fichiers, des entrées/sorties et de l'interface.
Le système de fichiers est organisé en arbre avec une racine (/).
Chemin absolu : depuis la racine (/home/alice/doc.txt). Chemin relatif : depuis le répertoire courant.
Commandes essentielles : pwd, ls, cd, mkdir, cp, mv, rm, cat, chmod.
Trois types de droits : lecture (r), écriture (w), exécution (x), pour trois catégories : propriétaire, groupe, autres.
chmod modifie les droits : notation symbolique (u+x) ou numérique (755).
Un processus = programme en cours d'exécution, identifié par un PID.