Aller au contenu

Administration Unix - CM séance 01

0. Description de l'UE

Présentation :

  • UE SRTAU10L - "Administration systèmes et réseaux Linux 1"
  • Responsable : Edouard.Thiel@univ-amu.fr
  • Lien court vers ce site du cours : https://j.mp/au-et

Ce cours est composé de 2 modules :

  • 10 séances au semestre 1 du M1 :

    • Le shell bash : syntaxe, utilisation
    • Commandes Unix pour l'utilisateur standard, manipulations courantes
    • Programmation de scripts en bash

  • 10 séances au semestre 2 du M1 :

    • Les bases de l'administration système sous Linux (Debian, Ubuntu...)
    • La gestion des systèmes de fichiers
    • La gestion des paquets, l'installation de programmes
    • Configuration de machines virtuelles Virtualbox
    • Administration réseau, configuration de services (syslog, ssh...)

But : être capable d'installer et d'administrer une machine sous Unix.

Comment travailler ce cours ?

  • prenez beaucoup de notes ;
  • après chaque séance, complétez le cours, de mémoire, avec vos remarques ;
  • testez chaque commande, faites des variantes ;
  • imaginez des petits exercices ;
  • tenez à jour un "pense-bête" avec les points et exemples qui vous semblent importants.

L'idéal est d'installer Ubuntu (20.04 LTS) sur votre ordinateur personnel, ou encore WSL.

Évaluation (MCCC) en session 1 :

  • au semestre 1 :
    • rendu de TPs (50%);
    • examen final (50%) ;
  • au semestre 2 :
    • rendu de projets par équipes (100%).

À l'examen vous pourrez amener un aide-mémoire personnel (1 seule feuille A4 recto-verso) ; tous les autres documents et calculettes sont interdits.

1. Présentation des systèmes Unix

Il s'agit d'une famille de systèmes d'exploitation

  • fortement liée au langage C
  • avec une "philosophie" commune ("tout est fichier", ...)

Note : cette partie sera vue rapidement en cours, vous pourrez la relire plus en détail chez vous.

1.1. Historique

Genèse :

  • 1964 : Projet "Multics" de système d'exploitation (avec le MIT, General Electric, Bell Labs d'AT&T).

    But : multi-tâche, multi-utilisateur, terminal distant, édition de liens dynamique, système de fichier hiérarchisé, shell, ...

    En 1969, Bell Labs se retire du projet (retards, trop cher, complexe...).

  • 1969 : Ken Thompson et Dennis Ritchie (Bell Labs) créent en ASM un S.E. plus simple, sur un ordinateur de récupération (DEC PDP 7 de 1964).

    Il sera par la suite nommé "Unix", par opposition à Multics, à la suite d'un jeu de mots de Brian Kernigham (Bell Labs).

  • 1970-71 :

    • V1 : Réécriture sur PDP11 (16 bits, 24K Ram, 512K DD) ;
    • Ken Thompson et Denis Ritchie créent le langage B (inspiré de BCPL)

  • 1972-73 :

    • Denis Ritchie crée le langage C (inspiré de B)
    • V2 : Ken Thompson réécrit entièrement Unix en C

  • 1975 : les sources sont fournis à : Bell, AT&T, et UCB (Univ. Berkeley)

    => 3 branches principales de développement :

    • Bell (branche recherche d'AT&T) : (PWB/Unix, Plan 9)
    • AT&T branche commerciale : .. 1988 SysVR4 .. Sun, HP, SGI, Dec, IBM
    • UCB : 1977 BSD .. 2000 MacOSX ..

Historique complet :

Problème : nombreux Unix incompatibles ⟶ portabilité ?

Normalisation : POSIX (IEEE, depuis 1988)

  • 3 normes, 17 documents
  • API ; commandes et utilitaires Unix ; tests de conformité
  • documents et certifications coûteux

Émergence des logiciels libres :

Projet GNU :

  • 1983, Richard Stallman, "GNU is Not Unix"
  • But : réécrire un Unix libre (utilitaires ; noyau Hurd, jamais fini)

Linux :

  • 1991 : Étudiant finlandais Linus Torvalds, projet de Master 1 !

    = écrire un noyau Unix inspiré du système MINIX (Tanenbaum) sur i386

  • appel à contribution sur internet, licence libre

  • version 1.0 en 1994
  • depuis, développement ininterrompu (28 millions de lignes en 2020)
Distribution GNU/Linux :
= noyau Linux + utilitaires GNU + logiciels libres + documentation + installeur : Ubuntu, Debian, Redhat, Fedora, CentOS, Suse, Slackware, etc

Aujourd'hui :

  • Linux dans : 99% Top 500 supercalculateurs, data centers, serveurs web, Android, liseuses, box internet, ...
  • Sur voitures : QNX (un Unix RT commercial), Linux (Tesla, Toyota,...)
    voir https://en.wikipedia.org/wiki/Automotive_Grade_Linux
  • Smart TV : basés sur Linux (Roku, webOS, Android TV, Tizen, Fire TV...)
  • Windows 10/11 : WSL2 (noyau Linux + Ubuntu dans machine virtuelle légère Hyper-V)

1.2. Caractéristiques

En commun :

  • Un "noyau"
  • Multi-tâche
  • Multi-utilisateur
  • Orienté réseau
  • Système de fichier hiérarchique, droits similaires
  • Des centaines de commandes, par exemple le shell
  • Des variables d'environnement (le chemin courant, le user, etc)
  • L'environnement graphique X11 + gestionnaires de fenêtres

La plupart des fonctions sont assurées par le noyau :

  • Gestion des processus
  • Gestion de la mémoire (Mémoire physique RAM / espace de swap disque)
  • Gestion du système de fichier
  • Gestion des entrées/sorties
  • Gestion du réseau

Les fonctionnalités annexes sont assurées par des programmes qui interagissent avec le noyau :

  • Fonction de démarrage et de surveillance des processus (sysV init, systemd, ...)
  • Environnement graphique : serveur X11 ou Wayland, Window Manager, Bureau...
  • Serveur mail, web, ssh, dhcp, syslog, ...

Autres éléments :

  • Les scripts de démarrage
  • Le gestionnaire de programmes de type apt, dnf, fink, etc.
  • Les programmes eux-même : commandes, logiciels, serveurs...
  • Gestion des utilisateurs : dans un fichier /etc/passwd ou dans des bases de données (LDAP).

1.3. Le shell

Le shell est un programme qui sert d'interface entre l'utilisateur et le noyau, dans un terminal en mode texte.

Différences entre shell, terminal, console :

  • un terminal est un programme qui gère l'affichage de texte et la saisie, et lance un shell. Par ex. xterm, gnome-terminal. Raccourcis clavier : Ctrl+Alt+T
  • une console = terminal physique (écran + clavier)

  • consoles virtuelles : Ctrl+Alt+F1 .. F6

    retour au mode graphique : Ctrl+Alt+F7 .. F12 (displays X11)

Fonctionnement habituel d'un shell = le "mode interactif" :

  • affiche une invite, appelée "prompt" (par ex. $),
  • attend que l'utilisateur saisisse une ligne + [Entrée],
  • analyse la syntaxe (symboles, mots clés...)
  • exécute les commandes correspondantes,
  • attend leur terminaison, puis ré-affiche le prompt

Un shell peut aussi lire des lignes depuis un fichier = un "script shell" :

  • premier shell développé : Thompson shell, par Ken Thompson, 1971
  • remplacé par le Bourne shell "sh", Steve Bourne, Bell Labs, 1979, Unix V7 qui est le shell de référence.

Plusieurs shells sont disponibles :

  • bash (Bourne Again SHell, clone libre), shell du projet GNU
  • dash (Debian Almquist shell), POSIX, plus rapide
  • Autres : csh, tcsh, ksh, zsh, ...
  • /bin/sh est un lien vers l'un de ces shells :
$ file /bin/sh
/bin/sh: symbolic link to dash

Ils ont :

  • des fonctionnalités différentes (fonctions, jobs, ...)
  • des syntaxes différentes (par ex. syntaxe C-like, sh-like, ...)
  • ou communes (par ex. la redirection d'entrée sortie, via | ).

Documentation en ligne :

$ man bash         # page de manuel
$ apropos signal   # recherche de commande par mot clé ; ou man -k
$ man 7 signal     # affichage de la section 7
$ help echo        # aide sur une builtin (commande interne) de bash
$ info gcc         # documentation hypertextuelle

Auto-documentation :

$ man man
$ help help
$ info info

Jargon : voir le glossaire

RTFM!   Read The Fucking Manual!
TL;DR   Too Long; Didn't Read

2. Gestion des fichiers

2.1. Le système de fichier

Système hiérarchique, en forme d'arbre inversé :

$ tree
/
├── bin
├── etc
└── home
    ├── user1
    │   ├── cours
    │   └── public_html
    └── user2

La racine est le répertoire /

Chaque répertoire contient une liste de fichiers et sous-répertoires.

Les disques et les partitions sont disposés dans l'arbre ("montés") avant de pouvoir être accédés (par ex. /home).

On distingue les noms de fichiers

  • normaux
  • cachés, qui commencent par "."
$ ls        # affiche les fichiers normaux du répertoire courant
$ ls -a     # idem + cachés

Chaque répertoire contient obligatoirement ces 2 fichiers cachés :

  • . : lui-même
  • .. : le répertoire parent

À partir d'un répertoire de travail, il existe 2 façons de noter un chemin pour aller dans un autre répertoire :

/
├── bin
├── etc
└── home
    ├── user1
    │   ├── cours
    │   └── public_html
    └── user2

  • chemin absolu, à partir de la racine : il commence par /

    /home/user1/cours$ cd /home/user2

  • chemin relatif :

    /home/user1/cours$ cd ../../user2

Remarque : non unicité des chemins :

/home/user1/cours$ cd ../../../etc/../home/./user2/

Manipulation de répertoires :

  • création : mkdir rep ...
  • création des chemins intermédiaires : mkdir -p rep ...
  • destruction (si vide) : rmdir rep ...

Exemple

Pour créer

foo
└── bar
    └── baz

on tape

$ mkdir foo foo/bar foo/bar/baz

ou

$ mkdir -p foo/bar/baz

Pour tout supprimer :

$ rmdir foo
rmdir: impossible de supprimer 'foo': Le dossier n'est pas vide
$ rm -rf foo        # /!\ PRUDENCE /!\

2.2. Types de fichiers

Il existe différents types de fichiers ; ce sont tous des fichiers !

  • fichier régulier (regular file) : contient des données
  • répertoire : contient une liste de fichiers
  • lien symbolique : contient une référence vers un endroit quelconque du système de fichiers
  • périphérique : il peut être en mode bloc ou en mode caractère
  • socket nommé ou tube nommé : pour la communication inter-processus
  • ...

Connaître le type des fichiers :

$ ls -l
-rw-rw-r-- 1 thiel thiel  150 sept. 21 14:21 truc
drwxrwxr-x 4 thiel thiel 4096 sept. 21 13:38 foo/
lrwxrwxrwx 1 thiel thiel   11 sept. 21 14:25 lien-foo ⟶ foo/bar/baz/
$ ls -l /dev/null
crw-rw-rw- 1 root root 1, 3 sept. 18 11:45 /dev/null
$ ls -l /tmp/.X11-unix/
srwxrwxrwx 1 root root 0 sept. 18 11:45 X0=
⟶ on regarde la première lettre :

-   fichier régulier
d   répertoire (directory)
l   lien
c   périphérique mode char
b   périphérique mode block
s   socket nommée
p   tube nommé

Liens : ils peuvent être de 2 types :

  • matériel : lien dans le même espace de stockage (inode)
  • symbolique : lien vers un endroit quelconque ; peut être invalide

Un inode est une structure bas niveau sur le disque, identifiée par un numéro ; les inodes sont créés une fois pour toutes au formatage de la partition. Un inode contient les adresses de blocs, les droits mais pas le nom d'un fichier.

Exemple

$ echo "salut" > alice      # création du fichier alice, contient "salut"
$ ln alice bob              # création lien matériel : même inode
$ ln -s alice choup         # création lien symbolique vers alice
$ ls -li alice bob choup    # ls avec en premier l'inode
2767693 -rw-rw-r-- 2 thiel thiel 6 sept. 21 15:47 alice
2767693 -rw-rw-r-- 2 thiel thiel 6 sept. 21 15:47 bob
2792136 lrwxrwxrwx 1 thiel thiel 5 sept. 21 15:47 choup ⟶ alice

En fait, un répertoire est un fichier qui contient une liste de couples (inode, nom de fichier).

Quelques commandes de manipulation de fichier :

  • pwd affiche le répertoire de travail du shell
  • cd change le répertoire de travail du shell
  • ls pour lister le contenu d'un répertoire
  • mkdir permet de créer des répertoires
  • rmdir supprime des répertoires vides
  • cp pour copier des fichiers
  • mv pour déplacer ou renommer des fichiers
  • touch pour créer/changer la date de modification d'un fichier
  • rm pour supprimer un fichier
  • ln pour créer un lien entre des fichiers
  • file donne une indication sur le type de données contenue dans un fichier
  • type donne le chemin d'une commande
  • tree affiche une hiérarchie de répertoires (mieux que ls -R)
  • cat affiche un fichier
  • more affiche un fichier écran par écran
  • du donne l'espace utilisé par un fichier ou une arborescence
  • df donne l'espace libre / utilisé, par partition

2.3. Droits

Les droits sur les fichiers sont définis pour 3 types d'utilisateurs, suivant 3 types de droits.

Les trois catégories d'utilisateurs sont : u,g,o
u   le propriétaire (user)
g   le groupe (group)
o   les autres (others)

Les trois types de droits sont : r,w,x

  • pour un fichier :
    r   lecture du fichier (read)
    w   écriture dans le fichier (write)
    x   exécution du fichier (execute)
  • pour un répertoire :
    r   droit de lire le catalogue des noms (ls)
    w   droit de modifier le catalogue = écrire un nom de fichier dans ce répertoire
    x   droit de "traverser" ce répertoire (crossing)
Les droits sont présentés sous la forme :
r, w, x (droits accordés) ou- (droit absent).
Par exemple :
rwxr-xr--   droits rwx pour le propriétaire, r-x pour le groupe, r-- autres

Les droits sont présentés par ls -l sous la forme :

  • 1er caractère : le type (- = fichier régulier)
  • les 9 suivants : les droits

Par exemple :

$ ls -l truc
-rwxr-xr-- 1 thiel thiel    10 sept. 21 14:21 truc

Manipuler les droits

La commande pour manipuler les droits est chmod :
chmod droits fichier...

⚠ Les droits ne peuvent pas être exprimés sous la forme affichée par ls.

Les droits peuvent être exprimés sous la forme u=...,g=...,o=... pour les spécifier, u+...,g+...,o+... pour rajouter des droits, u-...,g-...,o-... pour enlever des droits.

On peut regrouper u, g, o ou mélanger =, +, - ; par exemple chmod ug+w,o= signifie rajouter w à u et g et enlever tout droit à o.

On peut aussi utiliser la forme numérique en octal avec r = 4, w = 2, x = 1 ; par exemple pour rwx r-x r-- on obtient (4+2+1)(4+1)(4) = 754.

Exemples

$ chmod 640 truc    # donne les droits rw- r-- ---
$ ls -l truc
-rw-r----- 1 thiel thiel 0 sept. 23 09:24 truc

$ chmod +x truc     # rend le fichier exécutable pour tous
$ ls -l truc
-rwxr-x--x 1 thiel thiel 0 sept. 23 09:24 truc*

$ chmod u=rw,go-x truc     # donne le droit rw pour u, enlève x pour g et o
$ ls -l truc
-rw-r----- 1 thiel thiel 0 sept. 23 09:24 truc

Droits à la création :

Ils sont définis par le "umask" de l'utilisateur en faisant le "complément" :
777 & ~umask   pour un répertoire
666 & ~umask   pour un fichier

Exemples

$ umask         # affiche valeur courante en octal (commence par 0)
0022
$ umask -S      # affiche la valeur courante "symboliquement"
u=rwx,g=rx,o=rx

$ umask 027     # change la valeur courante
$ touch bidule    # crée un fichier vide ⟶ droits selon le umask
$ ls -l bidule
-rw-r----- 1 thiel thiel 0 sept. 21 19:00 bidule

$ mkdir chose   # crée un répertoire ⟶ droits selon le umask
$ ls -l | grep chose
drwxr-x--- 2 thiel thiel 4096 sept. 21 19:00 chose/
Autres commandes, réservées à root (vues plus tard) :
chown   change le propriétaire d'un fichier
chgrp   change le groupe d'un fichier

Droits étendus : certains systèmes de fichiers supportent des droits étendus, appelés les "ACLs" (vus au semestre 2).

2.4. Commandes find et tar

🐶  La commande find

Elle permet de rechercher des fichiers suivant leurs attributs : le nom, la taille, le type, les droits, le propriétaire, la date de modification, ... mais indépendamment du contenu de ces fichiers.

Usage : find options emplacements expression

options
Récursivité, traverser les liens symboliques, rester sur la même partition, etc.
emplacements
À partir de quelle(s) branche(s) du système de fichier.
expression
Conditions sur les attributs des fichiers ; action à effectuer ; options supplémentaires

Exemples

Cherche à partir de /home/thiel tous les fichiers .py et affiche leur nom 

$ find /home/thiel -name "*.py" -print

Cherche les fichiers .txt et .png 

$ find /usr \( -name '*.txt' -o -name '*.png' \)

Cherche dans /dev les périphériques de type bloc 

$ find /dev -type b

Cherche dans /tmp les fichiers appartenant à l'utilisateur thiel et d'une taille supérieur à 100k 

$ find /tmp -user thiel -size +100k

Cherche les liens symboliques puis exécute pour chacun ls -l 

$ find /dev -type l -exec ls -l {} \;

Cherche les fichiers modifiés depuis moins de 2 jours avec certains droits 

$ find /etc -mtime -2 -perm -444 -perm /222 ! -perm /111

💾  La commande tar

Il existe un format d'archive très commun sous unix : .tar (tape archive)

Il permet de recopier une arborescence de répertoire en conservant :

  • Les noms et chemins des fichiers
  • Les droits des fichiers, l'utilisateur et le groupe
  • Les liens symboliques ou physiques
  • Les types de fichier

On peut ainsi recopier une architecture complète de répertoire dans un seul fichier (une "archive tar", un "tarball").

Usages :

$ tar -c -f archive.tar files   # crée une archive qui contiendra les 
                                # fichiers files
$ tar -x -f archive.tar         # décompresse l'archive
$ tar -t -f archive.tar         # liste le contenu de l'archive

On rajoute souvent l'option -v (verbose) pour afficher les noms des fichiers.

Raccourcis :

$ tar cvf archive.tar files     # Création
$ tar xvf archive.tar           # Extraction
$ tar tvf archive.tar           # Liste
Autres options courantes (ou raccourcis) :
-p   préserve les droits des fichiers.
-z   (dé)compresse au format gzip ⟶ .tar.gz ou .tgz
-j   (dé)compresse au format bzip2 ⟶ .tar.bz2
-J   (dé)compresse au format xz ⟶ .tar.xz