Beaucoup de monde a été oublié dans cette présentation. Je ne parle pas par exemple des acteurs de Palo Alto, des inventeurs de ethernet, ou de Douglas Engelbart (inventeur de l'informatique moderne), etc.

Il y en a deux que je n'ai pas oublié en revanche, c'est Steve Jobs et Bill Gates. Ceux là sont des industriels qui n'ont jamais rien inventé d'autre que le fait de vendre beaucoup à beaucoup de monde. Cela dit, c'est grace à eux que l'ordinateur s'est démocratisé.

Regardez sur invidious: The Mother of All Demos, presented by Douglas Engelbart (1968) [HD 720p 2020 reupload]

• OS stable
• Fonctionne sur plusieurs achitectures dont
  • Intel X86 (les PCs, quoi)
  • ARM (tablettes, smartphones...)
  • SPARC
  • m68k (Macintosh collector)
  • Power PC(Macintosh aussi)
  • MIPS
  • RISC-V
  • ...
• usage courant en informatique embarquée
• Téléphonie
• Cloud

• Hyper-V
  • gratuit... mais jusqu'à quand ?
  • uniquement dans les versions pro et education
  • migration de machine ?
• Windows Subsystem for Linux
  • haute performance
  • sécurité ?
  • mise à jour de version majeure ?
• VirtualBox
  • Sous licence GPL v2
  • migrable, portable
  • performance ?
  • accès au hardware

la hierarchisation de l'information

• un chemin simple est de la forme "nom" où nom est un nom de fichier
• un chemin est un parcours dans l'arborescence
• il est composé des noms des fichiers parcourus séparé par le caractère "/"
• le chemin est dit relatif s'il commence par un nom, par "." ou par ".."
• le chemin est dit absolu s'il commence par la racine (notée "/")
• le chemin "." est le répertoire courant
• le chemin ".." est le chemin père
• le chemin est sensible à la casse (majuscules/minuscules)

							# exemples
							/							# chemin absolu  : root (ou racine du système de fichier)
							./Docs				# chemin relatif : répertoire Docs dans le répertoire courant
							../var				# chemin relatif : répertoire var dans le répertoire père
							./Docs/var		# chemin relatis : rep var dans le rep Docs, dans le rep courant
							

• La racine ou le root "/"
• bin (obsolete): binaires essentiels
• sbin (obsolete): binaires essentiels pour root
• boot : kernel/init RAMfs
• dev : périphériques
• etc : fichier de configuration
• home : home des utilisateurs
• lib : bibliothèques et modules du kernel
• media, mnt : montage des filesystems temporaires
• proc : fichier d'information kernel et process
• root : home du root
• usr : applications et données d'application en lecture seule
• var : fichiers de données variables

• /usr
• bin : binaires essentiels
• include : fichier include standard pour langage C
• lib : bibliothèque
• local : usr local
• sbin : binaire essentiel pour root
• share : fichiers de donnée partagé entre architectures

• /var
• cache : cache applicatif
• lib : données modifiables en cours d'exécution
• lock : fichiers de verrouillage des processus
• log : fichiers de logs
• mail : ... à votre avis ?
• spool : spool applicatif (spool/mail, spool/rsyslog, ...)

Préparation:

							$ mkdir source cible
							$ touch ./source/fichier
							$ ls -l ./source/fichier
							-rw-rw-r-- 1 rg rg 0 sept. 22 22:46 fichier
							$
							

Exécution:

							$ ln source/fichier cible/
							$ ls -l source/fichier
							-rw-rw-r-- 2 rg rg 0 sept. 22 23:09 source/fichier
							$ ls -l cible/fichier
							-rw-rw-r-- 2 rg rg 0 sept. 22 23:09 cible/fichier
							$
							

la commande ln lie la cible à un autre répertoire (le lien est passé à 2). Le fichier "fichier" n'est présent qu'une fois sur le disque mais est accessible dans 2 répertoires

la commande rm

							$ ls cible
							fichier
							$ rm cible/fichier
							$ ls cible
							$
							

La commande rm supprime le lien du fichier dans le répertoire (courant par défaut, nommé sinon)

Préparation:

							$ ls -l ./source/fichier
							-rw-rw-r-- 1 rg rg 0 sept. 22 22:46 fichier
							$
							

Exécution:

							$ cp source/fichier cible/
							$ ls -l source/fichier
							-rw-rw-r-- 1 rg rg 0 sept. 22 23:09 source/fichier
							$ ls -l cible/fichier
							-rw-rw-r-- 1 rg rg 0 sept. 22 23:09 cible/fichier
							$
							

La commande cp copie un fichier source dans une cible. C'est une commande complexe avec de nombreuses options

Préparation:

							$ rm ./cible/fichier
							$ ls -l ./source/fichier
							-rw-rw-r-- 1 rg rg 0 sept. 22 22:46 fichier
							$
							

Exécution:

							$ mv source/fichier cible/
							$ ls -l source/
							$ ls -l cible/fichier
							-rw-rw-r-- 1 rg rg 0 sept. 22 23:09 cible/fichier
							$
							

La commande mv déplace les fichiers. Son comportement est différent en fonction du type de fichier de ses arguments

la commande stat

							$ stat source/fichier
								Fichier : source/fichier
									 Taille : 0           Blocs : 16         Blocs d'E/S : 4096   fichier vide
							 Périphérique : 38h/56d  Inœud : 1059414     Liens : 2
							 Accès : (0664/-rw-rw-r--)  UID : ( 1000/      rg)   GID : ( 1000/      rg)
							 Accès : 2022-09-22 23:09:25.068295540 +0200
							 Modif. : 2022-09-22 23:09:25.068295540 +0200
							 Changt : 2022-09-22 23:10:24.452466827 +0200
								 Créé : -
							$
							

La commande stat affiche les métadonnée des fichiers en argument. Elle admet un paramètre -f...

la commande file

							$ file source/fichier
							empty
							$ file source
							source: directory
							$ file /bin/bash
							/bin/bash: ELF 64-bit LSB shared object, x86-64  ...
							$
							

La commande file affiche le type des fichiers en paramètre

la commande type

							$ type bash
							bash est /usr/bin/bash
							$ type cd
							cd est une primitive du shell
							$ type ls
							ls est un alias
							$
							

La commande type affiche le type des commandes en paramètre

							## manipulation des répertoires
							mkdir								## crée un répertoire
							rmdir								## supprime un répertoire vide
							cd									## change le répertoire courant
							## manipulation des fichiers
							touch fichier				## Met à jour l'heure de modification du fichier ou le créer
							rm fichier					## supprime le lien du fichier dans le répertoire
							ln source rep				## rajoute un lien (dit hard) du fichier source vers rep
							cp source cible			## copie le fichier standard source sur (ou dans) cible
							mv source cible			## déplace source vers cible
							## interfaces de lecture
							stat fichier				## écrit les métadonnées de fichier
							file fichier				## affiche le type de fichier
							type fichier				## affiche le type de commande
							ls fichier					## liste l'argument
							

L'ensemble de ces commandes permettent de faire grossièrement à peu près tout sur un système de fichier. Il ne manque que la synchronisation qu'on verra plus tard (en traitant le problème des backups).

autre que répertoire et fichier standard

• Les périphériques. Ce sont des fichiers de type bloc ou texte. On les trouves essentiellement dans /dev

								$ ls -l /dev/vda
								brw-rw---- 1 root disk 254, 0 23 sept. 18:54 /dev/vda
								$ ls -l /dev/tty
								crw-rw-rw- 1 root tty 5, 0 23 sept. 18:54 /dev/tty
								$
								

• Les sockets. Ce sont des fichiers d'entrée/sortie: ils servent à communiquer avec le process qui les a ouverts. On les trouve dans /var.

								$ ls -l /var/run/udev/control
								srw------- 1 root root 0 23 sept. 18:54 /var/run/udev/control
								$
								

• Le BASH est avant tout un programme de substitution
• il repère des caractères spéciaux et substitue ces caractères par leur correspondance
• Les substitution sont gérés par les caractères " et '
• Entre ", seuls la substitution de variable a lieu
• Entre ', aucune substitution n'a lieu
• Pour retirer temporairement la signification d'un caractère spécial, on le fait précéder de \

Pour chaque ligne de commande, Bash effectue 7 opérations appelées "remplacement", "développement" ou "substitution". Ces opérations sont

1. Le développement des accolades: (mkdir -p cours/cours{1,2} ?)
2. Le développement du tilde (~)
3. Le remplacement des paramètres (les variables)
4. La substitution de commande (commande exécutée dans une commande)
5. Le développement arithmétique (calculs)
6. La substitution de processus (super | )
7. Le développement des chemins (globbing: man 7 glob)

Ces développement sont effectués dans cet ordre

Le développement des accolades

Le développement des accolades a lieu entre accolades non précédées par le signe $

• les chaines séparées par des virgules sont développées en chacune des chaines:
  {1,f5,coucou} est développé en 1 f5 coucou
ab{cd,ef,gh}ij est développé en abcdij abefij abghij
• les objets séparés par ".." sont développés en ensemble logique avec incrément de 1
  {1..5} est développé en 1 2 3 4 5
{f..j} est développé en f g h i j
{f..a} est développé en f e d c b a
  Les ensembles incohérents ne sont pas développés
• Dans cette deuxième forme, on peut fixer l'incrément
  {1..10..3} est développé en 1 4 7 10

Le développement des accolades

Comment on s'en sert ?

							$ mkdir -p cours/cours{1,2}
							## est développé en : mkdir -p cours/cours1 cours/cours2
							$ touch fichier{1..3}.{c,h}
							## est développé en : touch fichier1.{c,h} fichier2.{c,h} fichier3.{c,h}
							## lui même développé en : touch fichier1.c fichier1.h fichier2.c fichier2.h fichier3.c fichier3.h
							

Le développement du Tilde ~

• Le tilde ~ est développé en le chemin du propriétaire du process.
• Le nom utilisé est le nom réel (RUID), pas le nom effectif (EUID)

							$ echo ~
							/home/rg
							$ exit
							....
							login: root
							password:
							...
							# echo ~
							/root
							#
							

Le remplacement des paramètres (variables)

• Un paramètre contient une valeur
• Une variable est un paramètre nommé
• Le nom est composé de lettres et de chiffres
• Une variable est soumise au développement du tilde, au remplacement des variables, à la substitution de commande, à l'évaluation arithmétique et à la suppression des protections
• On affecte une valeur à une variable avec le métacaractère =, il ne doit pas y avoir d'espace entre le nom de la variable et le métacaractère =
• Une variable existe à partir du moment ou on lui affecte une valeur, y compris la valeur NULL
• Une variable est détruite avec la commande interne unset
• Une substitution de paramètre est effectuée en utilisant la forme $NomVar ou ${NomVar}

Le remplacement des paramètres (variables): exemples

									$ var=coucou
									$ echo $var
									coucou
									$ echo ${var}
									coucou
									$ echo $var2
									$ echo ${var}2
									coucou2
									$
									

									$ var=mon fichier
									fichier: commande introuvable
									$ echo $var
									mon
									$ var="mon fichier"
									$ echo $var
									mon fichier
									$ autre_var=$var
									$ echo $autre_var
									mon fichier
									$ autre_var='$var'
									$ echo $autre_var
									$var
									$ autre_var="J'ai mis $var dans "\''$var'\'
									$ echo $autre_var
									J'ai mis mon fichier dans '$var'
									$
									

Le développement des chemins

On utilise des caractères particuliers qui servent à décrire des pattern

• *: représente 0 ou plus caractère quelconque. Si aucune correspondance n'est trouvé, il n'est pas substitué
• ?: représente 1 caractère quelconque. Si aucune correspondance n'est trouvé, il n'est pas substitué
• [...]: une plage de caractère. [a-z] représente tous les caractères minuscule, [0-9] tous les chiffres, [123] les caractères 1, 2 et 3 (peut aussi s'écrire [1-3])

Ne confondez pas le développement des chemins (qui est un développement sur des noms de fichiers existant) et celle des accolades (qui est simplement un développement texte)

• Il s'agit d'exécuter une commande dans une autre
• On utilise la notation '`' (backquote ou AltGr è) ou $(liste)

• Le fichier d'entrée standard est le fichier 0 (stdin)
• Le fichier de sortie standard est le fichier 1 (stdout)
• Le fichier d'erreur standard est le fichier 2 (stderr)
• l'existence de ces fichiers est garantie par le noyau

Par défaut, le fichier d'entrée standard est relié au clavier, les fichiers de sorties et d'erreur sont liés au TTY (l'écran...)

L'ensemble de ces fichiers est appelé standard i/o ou std i/o. Leur définition est contenu (en C) dans la bibliothèque stdio.h qui sera quasi systématiquement inclus dans les programmes grace à:

							#include <stdio.h>
							

et ne dites pas "l'écran"

• le méta-caractère ">" créer un fichier en écriture
• le méta-caractère ">>" ouvre un fichier en ajout
• le méta-caractère "<" redirige un fichier vers l'entrée standard

on peut rediriger n'importe quel flux, y compris les i/o standard (/dev/null est un trou sans fond: c'est la poubelle d'unix)

							## redirige stderr (fichier 2) vers /dev/null
							$ echo coucou 2>/dev/null   
							coucou
							## redirige stderr vers /dev/null et stdout sur stderr (donc aussi)
							$ echo coucou 2>/dev/null 1>&2
							$
							

et ne dites pas "l'écran"

• La commande cat concatène les fichiers en arguments ou sur son entrée standard avec le paramètre - et les écrits sur sa sortie standard

							$ echo coucou >fichier1
							$ echo toto >fichier2
							$ cat fichier1 fichier2
							coucou
							toto
							$ cat - fichier1 <fichier2
							toto
							coucou
							$
							

• cut: enlève des sections de ligne d'un fichier
• sort: trie les lignes d'un fichier
• sed: éditeur de flux en ligne de commande
• grep: recherche de motif dans des fichiers
• uniq: affiche les lignes d'un fichier en supprimant les occurrences consécutives

Une petite préparation est nécessaire...

							$ echo Bonjour monde 10 >fichier
							$ echo 1 >>fichier
							$ echo 2 >>fichier
							$ echo 1 >>fichier
							$ echo Au revoir >>fichier
							$
							

écrit le premier champ du fichier, chaque champ étant séparé par un espace

							$ cut -d ' ' -f 1 fichier
							Bonjour
							1
							2
							1
							Au
							$
							

écrit le premier champ du fichier, chaque champ étant séparé par un e

							$ cut -d 'e' -f 1 fichier
							Bonjour mond
							1
							2
							1
							Au r
							$
							

trie le fichier dans l'ordre alphabétique

							$ sort fichier
							1
							1
							2
							Au revoir
							Bonjour monde 10
							$
							

N'affiche que les chiffres

							$ grep -o '[0-9]*' fichier
							10
							1
							2
							1
							$
							

Affiche les lignes ne contenant que des chiffres

							$ sed -ne '/^[0-9]*$/p' fichier
							1
							2
							1
							$
							

							## manipulation des répertoires
							mkdir								## crée un répertoire
							rmdir								## supprime un répertoire vide
							cd									## change le répertoire courant
							## manipulation des fichiers
							touch fichier				## Met à jour l'heure de modification du fichier ou le créer
							rm fichier					## supprime le lien du fichier dans le répertoire
							ln source rep				## rajoute un lien (dit hard) du fichier source vers rep
							cp source cible			## copie le fichier standard source sur (ou dans) cible
							mv source cible			## déplace source vers cible
							## interfaces de lecture
							stat fichier				## écrit les métadonnées de fichier
							file fichier				## affiche le type de fichier
							type fichier				## affiche le type de commande
							ls fichier					## liste l'argument
							## les filtres
							cut	fichier					## enlève des sections de ligne d'un fichier
							sort fichier				## trie les lignes d'un fichier
							sed [reg] fichier		## éditeur de flux en ligne de commande
							grep [reg] fichier  ## recherche de motif dans des fichiers
							uniq fichier				## affiche les lignes d'un fichier en supprimant les occurrences consécutives
							

• Ce sont des ensembles de commandes regroupées au sein d'un fichier
• Les scripts permettent l'accès aux arguments à travers les paramètres positionnels
• Le langage Bash possède des structures de contrôle (if, then, while, for, case...)
• N'oubliez pas la philosophie KISS
• Nous utiliserons nano pour écrire les scripts (enfin... les flemmards)
• Les courageux utiliserons un vrai éditeur: vi

The first one

• la manière la plus simple de lancer un script:

  
  									$ bash script.sh
  									

• La manière la plus standard:

  
  									$ chmod +x script.sh
  									$ ls -l script.sh
  									-rwxr-xr-x 1 rg rg 556 4 oct. 11:46 script.sh
  									$ ./script.sh
  									

• En mode interactif

  
  									$ bash <script.sh
  									

• Dans l'environnement local

  
  									$ source script.sh
  									

Les structures de contrôle

La structure if liste; then liste; [elif liste; then liste; ] ... [else liste]; fi

• C'est la structure conditionnelle du bash
• La liste du if est exécutée. Si la valeur renvoyée est 0 (zéro), alors la liste du then est exécutée
• Si la valeur est différente de 0, la liste du elif est exécutée s'il y a lieu, sinon, celle du else s'il y a lieu

Les commandes [[ et test font appel à des primitives qui sont

									#!/bin/bash

									f="$1"

									if [[ -z "$f" ]]; then
										echo Argument non fourni >&2
										exit 127
									fi

									if [[ -e "$f" ]]; then
										echo "$f est un fichier et existe"
										if [[ -f "$f" ]]; then
											echo "$f est un fichier standard"
										elif [[ -d "$f" ]]; then
											echo "$f est un répertoire"
										fi
									else
										echo "$f n'existe pas"
									fi
									

La structure de contrôle

La structure while liste1; do liste2; done

• C'est une des structure de contrôle de boucle du bash
• La liste liste2 est répétée tant que le résultat de liste1 est nul
• il existe une commande until rarement utilisée qui a la même forme, sauf que liste2 est alors répétée tant que liste1 est non nul

exemple

							while read ligne; do
								##traitement de chaque ligne de "fichier"
							done <fichier
							

La structure de contrôle

La structure for nom [ [in [ mot ... ] ]; ] do liste; done

• C'est une structure de boucle itérative
• La liste de mot suivant in est développé en une liste d'éléments.
• La variable nom prendra la valeur de chacun de ses éléments, et liste sera exécuté à chaque fois

exemple

							for f in ./Documents/fichier{1..5}; do
								echo "une ligne de plus" >>"$f"
							done
							

• Installation:
  rpm -i paquet.rpm
• Suppression:
  rpm -e paquet
• Mise à jour d'un paquet, l'installe s'il ne l'est pas:
  rpm -U paquet
• Interrogation de la base installée:
  rpm -q
• Voir les informations sur un paquet (Query Insformation):
  rpm -qi paquet
• Lister les fichiers d'un paquet (Query List):
  rpm -ql paquet
• Lister les paquets installés (Query All):
  rpm -qa
• Vérifier un paquet:
  rpm -V paquet

yum: Yellow dog Updater Modified

• Permet de récupérer, installer, gérer les paquets depuis les dépôts
• Gère les dépendances
• Configuration dans /etc/yum.conf
• dépôts dans /etc/yum.repos.d

yum: Yellow dog Updater Modified

• installation d'un paquet:
  yum install paquet
• recherche d'un paquet:
  yum search paquet
• suppression d'un paquet:
  yum remove paquet
• mise à jour d'un paquet:
  yum update paquet
• mise à jour des paquets:
  yum update
• dnf est a version moderne de yum.

• Installation:
  dpkg -i paquet.deb
• Suppression:
  dpkg -r paquet
• Suppression complète (y compris configuration):
  dpkg -P paquet
• Voir les informations sur un paquet:
  dpkg -I paquet.deb
• Trouver le paquet qui contient un fichier particulier:
  dpkg -S /chemin/vers/fichier
• Lister les paquets installés:
  dpkg -l
• Reconfiguration d'un paquet:
  dpkg-reconfigure paquet
• Et pour finir: pour cloner une machine, sur la première:
  # dpkg --get-selections >mespaquets
  Sur la deuxième
  # dpkg --set-selections <mespaquets
# apt-get upgrade

apt: Advanced Packaging Tool

• Permet de récupérer, installer, gérer les paquets depuis les dépôts
• Gère les dépendances
• Configuration dans /etc/apt
• dépôts dans /etc/apt/source.list et /etc/apt/source.list.d/

apt: Advance Packaging Tool

• Mise à jour de la base:
  apt update ## ou apt-get update sur les vieilles versions
• installation d'un paquet:
  apt install paquet
• recherche d'un paquet:
  apt search paquet ## ou apt-cache search paquet
• suppression d'un paquet:
  apt remove paquet
• mise à jour de l'ensemble des paquets:
  apt upgrade ## obsolete
• mise à jour de l'ensemble des paquets avec saut de version majeure:
  apt full-upgrade ## apt-get dist-upgrade
• réparation des dépendances (quand c'est possible):
  apt-get -f install
• suppression des paquets inutiles (après une mises à jour majeure):
  apt autoremove

depuis les sources

• Téléchargez les sources
• décompactez (généralement: $ tar -xvzf paquet.tar.gz)
• cd dossierDuPaquet
• ./configure
• make
• make install

La configuration réseau se fait dans le fichier standard /etc/network/interfaces

Des fichiers additionnels peuvent être lus du dossier
/etc/network/interfaces.d/* et inclus dans la configuration

Par défaut, la configuration réseau fait appel à un serveur DHCP

							# The loopback network interface
							auto lo
							iface lo inet loopback

							# The primary network interface
							allow-hotplug ens18
							iface ens18 inet dhcp
							

Le redémarrage du réseau peut se faire avec
systemctl restart networking.service

Attention aux effet de bord ! (connexion ssh entre autre)

On peut fixer une ip statique aussi

							allow-hotplug ens18
							iface ens18 inet static
								address 192.168.5.210
								netmask 24
								gateway 192.168.5.1
								dns-nameservers 192.168.5.1 192.168.5.2
							

Par ailleurs, la commande ip permet la configuration en live

							ip addr add 192.168.5.210/24 dev ens18
							ip route add default via 192.168.5.1
							

La résolution DNS se fait dans le fichier /etc/resolv.conf

							domain exemple.com
							search exemple.com
							nameserver 192.168.5.1
							nameserver 192.168.5.2
							

• Un utilisateur est un identifiant numérique (UID)
• Il ne représente pas forcément un utilisateur physique
• Il est associé à au moins un identifiant de groupe (GID)
• L'ensemble des droits et limitations sont liés à ces identifiants: au niveau de filesystem, au niveau des autorisations d'accès ou des propriétés des processus
• La valeur de l'UID et du GID est comprise entre 0 et 65535 mais est sucseptible d'aller bien au delà (64 bits)
• Les valeurs inférieures à 100 sont "spéciales"
• Notament, l'UID/GID du root est 0/0
• L'UID d'un utilisateur physique commence souvent à 1000 (voir /etc/login.defs)
• De manière effective, le noyau gère 3 UIDs: le RUID (UID réel), le EUID (UID effectif) ainsi que le SUID (Saved UID)
• Les permissions des processus sont confrontés à l'EUID

Les groupes

• Chaque utilisateur fait au moins parti d'un groupe (chaque UID est lié à un GID au moins)
• Les autorisations de l'utilisateurs sont la somme des autorisations des groupes auquel il appartient
• Quand un utilisateur appartient à plusieurs groupes, il a un groupe primaire unique et des groupes secondaires. Le groupe primaire sera le groupe par défaut attribué à ses fichiers et processus
• Quand l'utilisateur est un utilisateur physique, par défaut, le nom de son groupe primaire est son nom d'utilisateur et il est le seul membre de ce groupe.
• Cela ne signifie pas que pour lui UID=GID
• Sous linux, un groupe ne peux pas faire parti d'un autre groupe
• La commande id est une interface de visualisation de ses informations

Les commandes de gestion

• useradd permet d'ajouter un utilisateur
• adduser aussi ! mais de façon interactive
• groupadd et addgroup ont les mêmes rôles mais pour les groupes
• usermod permet de modifier les comptes existants
• les fichiers (texte: rappelez vous la philosophie linux) de gestions des utilisateurs sont /etc/passwd, /etc/shadow, /etc/group et /etc/gshadow
• On peut modifier ces fichiers à la main, mais il est conseillé d'utiliser la commande vipw
• les commandes userdel et groupdel supprime utilisateur et groupe en argument
• les commandes pwck et grpck permettent de vérifier la cohérence des fichiers de gestion des utilisateurs
• Les commandes passwd et chpasswd permettent de changer le mot de passe
• Les commandes chage, chsh, chfn permettent de gérer la validité des mots de passe, le shell ou les commentaires GECOS

• C'est un système de classement permettant la gestion du disque dur (ou SSD), c'est à dire la mémoire de masse.
• Il en existe de multiple type: ext2, ext4, xfs, btrfs, zfs... Chacun de ces types réponds à une problématique donnée
• ils peuvent être associés (ou non) à un gestionnaire de partition tel que LVM2
• ext2 est souvent inclus dans le noyau, on l'utilisera lors du boot (dossier /boot)
• ext4 est le système standard, journalisé. C'est un FS en 32 bits (limité à des partition de 16To max)
• xfs est un système en 64 bits, plus rapide que ext4
• btrfs est le successeur de ext4. Il contient un gestionnaire de partition (et structure RAID) et est codé en 64 bits. Cela permet entre autre la gestion de snapshot
• zfs est un FS 128 bits avec gestionnaire de partition et structure RAID. Il gère les snapshots. Son inclusion dans le noyau linux est tardif (et dans sa version OpenZFS) pour cause d'incompatibilité de licence

Les outils

• Il existe plusieurs sortent de partition.
• On utilisera principalement une table de partition gpt ou dos sur les disques (attention, dos est un très vieux format)
• On pourra alors avoir 2 partitions principales et 1 partition étendue au maximum par disque
• Ceci est très insuffisant. On fera donc en sorte d'avoir des partitions logiques dans les partitions physique
• On utilise pour cela un gestionnaire de partition (LVM2) ou un FS capable de gérer le partitionnement (btrfs ou zfs)
• Les partitions logiques et physiques se chevauchent donc
• L'utilitaire fdisk permet la gestion des partitions physiques
• Il est souvent remplacé par l'utilitaire parted qui peut gérer les partitions gpt

Les outils

							$ sudo fdisk -l
								# affiche les toutes les partitions du système
							$ sudo fdisk /dev/vda # édite les partitions du disque /dev/vda
								# ATTENTION: vous êtes sur le disque système réel
								# QUITTEZ en faisant 'q'
							

Les outils

pour les système extN et xfs, on utilisera de préférence un gestionnaire de partition
• LVM2 est le gestionnaire de partition standard sous linux.
• Il fait la distinction entre volume "physique" (il s'agit en réalité de partitions), groupe de volume et partition
• Les commandes permettant de gérer LVM sont nombreuses
• Essayez lvs, vgs et pgs (avec les droits root)

Les outils

Pour la gestion des partitions logiques
• La gestion des volumes physiques (qui sont donc des partitions physiques) se fait avec pvs, pvcreate, pvmove, pvremove, pvdisplay
• Une fois les volmumes physiques marqués, il faut les associer à un groupe de volume
• Cette gestion se fait avec les commandes vgs, vgcreate, vgchange, vgremove, vgdisplay...
• Une fois le(s) groupe(s) de volume créé(s), on peut y installer des partitions
• La gestion des partitions se fait avec lvs, lvcreate, lvchange, lvremove, lvdisplay...
• Ce n'est qu'ensuite qu'on pourra formater (c'est à dire installer un système de fichier), puis monter le volume (càd attacher l'arborescence du volume à l'arborescence du système)

Les outils

Le formatage
• La commande permettant de formater une partition est mkfs. Il s'agit d'un front-end vers d'autres commandes

								$ sudo mkfs [-t type] [fs-option] device
								

• -t: permet de spécifier le FS a initialiser. Ex: ext2, ext4 ou xfs
• fs-option: permet de passer les options spécifiques au système de fichier
• device: le device (la partition) considérée

• Chaque FS peut avoir des options spécifiques
• En cas d'utilisation de ext4, la commande appelée par mkfs est mkfs.ext4 qui appelle lui même mke2fs
• En cas d'utilisation de xfs, la commande appelée est mkfs.xfs
• Dans le cas de mkfs, il est tout à fait possible de fournir comme device un fichier standard:

  
  								$ mkfs -t ext4 MonFichier
  								

  initialisera un FS ext4 dans le fichier MonFichier. Celui ci pourra ensuite être monté

Les outils

le montage
• C'est l'opération qui consiste à attacher au système de fichier un système de fichier étranger (exemple, attacher une clé USB)
• On utilise pour cela la commande mount

  
  								mount [-t fstype] [-o options] device dir
  								

• -t: généralement non fourni car reconnu: ext4, xfs...
• -o: options du FS: par exemple ro pour ext4 (montage Read-Only, très util en cas de récupération de backup
• device: c'est le device qu'on monte. Pour une clef USB, ça pourrait être /dev/sdb. Peut être un fichier standard
• dir: répertoire dans lequel on va attacher l'arborescence du device. Attention, si ce répertoire n'est pas vide, son contenu va être masqué
• Il faut ensuite démonter le device (commande umount)

Les outils

• Un certain nombre de commande permettent de gérer les FS
• df permet de voir l'espace disponible
• du permet de voir l'espace occupé par un répertoire
• fsck permet de réparer un FS (équivalent de chkdsk pour windows)
• dumpe2fs permet l'affichage des paramettres d'un FS
• tune2fs est un utilitaire permettant le réglage de nombreux paramètres d'un FS ext2, 3 ou 4
• les commandes lsblk et blkid vous permettent de récupérer les UUID des partitions
• Vous noterez l'absence de commande de défragmentation... les FS sont faits pour ne jamais en avoir besoin

le fichier /etc/fstab

• C'est le fichier qui fixe les montages au démarrage du système. Il est lu au cours du boot
• son format est

  
  								device DossierMontage TypeFS Options FrequenceDump FrequenceFsck
  								

• exemple

  
  								/dev/vda1	/				ext4	errors=remount-ro 0 1
  								/dev/vda2 /home		xfs		defaults					0 2
  								

• Il existe 2 manières standards de démarrer
• System V est le système d'origine, il lance un process (pid 1) appelé init
• Il est séquentiel: chaque service se lance dans l'ordre déterminé par le système pour atteindre un niveau
• Il y a 6(,5) niveaux
  • 0: Halt. Arrêt de l'OS (pas forcément arrêt électrique de la machine)
  • 1: Mono-utilisateur avec service minimum, utilisé pour de la maintenance
  • 2: Mono-utilisateur sans réseau, console
  • 3: Multi-utilisateurs, avec réseau, console (mode standard, hors graphique)
  • 4: Comme le 3, configurable par le sysadmin
  • 5: Multi-utilisateurs, avec réseau, avec serveur X (serveur graphique)
  • 6: reboot
  • S,s: Mode de récupération

Systemd

• systemd n'utilise pas de niveau, mais des target
• L'ensemble des services se lance grace à un jeu de dépendance
• Un service dépend éventuellement d'un autre service et fourni un état
• La résolution de l'arborescence permet de démarrer les services en parallèle
• Par exemple, sshd (service ssh) fourni par multi-user.target dépend de network.target
• La configuration des services est géré dans /etc/systemd

La commande unique permettant de gérer les services et les target est systemctl

• systemctl get-default permet d'obtenir la target par défaut
• systemctl set-default New.Target permet de fixer la target par défaut
• systemctl list-dependencies multi-user.target permet de lister sous forme arborescente les dépendances d'une target

La commande systemctl permet aussi de gérer les services et de les inscrire dans une target

• systemctl status srv.service permet de connaître le statut du service srv
• systemctl enable srv.service permet d'inscrire pour un démarrage automatique dans la cible courante le service srv
• systemctl start srv.service permet de démarrer un service
• systemctl stop srv.service permet de stoper un service
• systemctl permet de lister tous les services et leur état

Les process sont des "programmes" en cours d'exécution. On y retrouve les services mais aussi les applications
• La liste des process et de leur pid s'affiche avec la commande ps. PAr défaut, seuls les process de l'utilisateur sont affichés

  
  									$ ps
  										PID TTY          TIME CMD
  										2996 pts/0    00:00:00 bash
  										3133 pts/0    00:00:00 ps
  									

• La commande top permet d'avoir une vision dynamique des process; entre autre avec leur consommation de ressources
• On peut envoyer des messages (les signaux) à travers le service de messagerie du noyau avec la commande mal nommée kill. Les plus courants sont
  • SIGTERM : oblige l'applciation à terminer
  • SIGKILL : kill le process (directement au niveau du noyau)
  • SIGHUP : habituellement, oblige un service à relire ses fichiers de configuration
  • SIGUSR1 et SIGUSR2: user defined
  • SIGSTOP: stop un process (ne le tue pas: lui interdit simplement de s'exécuter)
  • SIGSTART: redémarre le process s'il a été préallablement stopé

• Le noyau linux est un noyau monolithique modulaire
• Cela signifie qu'il est relativement gros et intègre dans son corps la plupart des pilotes
• On peut néanmoins en rajouter sous forme de module
• Le noyau fonctionne dans un mode particulier: le mode noyau (!). Le deuxième mode est le mode utilisateur
• Le but d'un noyau est de passer le moins de temps possible en mode noyau. Ainsi, un pilote fonictionnera le plus possible en mode utilisateur et ne passera en mode noyau qu'au moment de l'accès matériel.
• Le mode noyau est réservé au noyau: aucune application utilisateur n'y tourne jamais
• La transition entre mode noyau et mode utilisateur est couteuse en cycles, c'est la principale raison de la perte de performance dans les systèmes virtualisés.

• Les information sur le noyau sont accessibles via la commande uname et ses options
• uname -s: Le nom du noyau
• uname -i: la plateforme
• uname -r: la révision du noyau
• uname -a: toutes les informations disponibles

							$ uname -a
							Linux INFAL51 5.10.0-20-amd64 #1 SMP Debian 5.10.158-2 (2022-12-13) x86_64 GNU/Linux
							$
							

• Les modules disponibles sont présents dans /lib/modules/[version-noyau]
• Ils possèdent l'extension .ko; ce sont fondamentalement des fichiers objets (.o) pour le kernel (le k)
• On peut les lister avec la commande lsmod
• La commande modinfo fournit des informations sur les modules
• L'ajout (le chargement) et retrait d'un module se font avec la commande modprobe
• L'ensemble de la configuration des modules se fait dans /etc/modprobe.d

• /proc est un dossier virtuel, il est instancié par le noyau et n'a pas d'existance physique sur le disque
• N'écrivez pas dedans sans savoir ce que vous faites ! À titre d'exemple, le fichier /proc/sys/net/ipv4/ip_forward définit le routage en ipv4
• un certain nombre de fichier peuvent être utils à l'analyse d'un système:
  • /proc/cpuinfo: contient des information sur les processeurs
  • /proc/meminfo: contient des informations sur la mémoire
  • /proc/devices: contient des informations sur les devices
  • /proc/modules: contient des informations sur les modules chargés (même résultat que lsmod, en moins propre !)
  • /proc/mount: informations sur les montages (même résultat que mount sans options)

• Le noyau, au démarrage, journalise ses informations dans le kernel ring buffer
• C'est un espace limité en taille et réservé au noyau
• On y accède à travers la commande dmesg
  • -l, --level: permet de restreindre l'affichage au niveau demandé:

    
    											$ sudo dmesg --level=err,warn #permet de restreindre au niveau error et warning
    											

  • -H: lisible par un humain...

• Une fois le système démarré, la journalisation fonctionne grace au service syslog (ou un de ses dérivés: rsyslog sur debian). à partir de la version 12 de debian, rsyslog est abandonné au profit de journald.
• Ces services classent l'information fonction d'un sous système applicatif (appelé facility) et en niveaux
• Sa configuratyion se fait dans /etc/rsyslog.conf, notamment le fait de déporter les logs
• Parmi les facilities remarquables, on peut citer:
  • kern: fichier /var/log/kern.log: message du noyau
  • auth: fichier /var/log/auth.log: messages relatifs à l'authentification
  • syslog: fichier /var/log/syslog: messages de rsyslog lui même (principale source de recherche d'erreur)
  • local0 à local7: configuration par le sysadmin
• La commande journalctl permet de visualiser les logs d'un service particulier

Les niveaux permettent de classer la criticité de l'information
• debug: information de débogage
• info: informations quelconques
• notice: informations pertinentes
• warn: avertissement
• err: erreur
• crit: conditions critiques
• alert: conditions critiques et urgence
• emerg: urgence maximale sur erreur critique (il est probable que le système de ne soit plus utilisable à ce niveau là)

Journald est un mini ELK. Il permet notamment l'indexation des logs et donc une consultation plus rapide. Il est structurellement plus lourd que rsyslog.

Sa configuration se fait dans /etc/systemd/journald.conf

Une fois configuré, le service doit être redémarrer avec systemctl reload systemd-journald.service. Dans les première version, il fallait un redémarrage complet du service (restart à la place de reload).

journalctl est la commande qui permet de manipuler les logs. Il utilise less comme pager.

• journalctl -n 20 affiche les 20 dernières lignes, de la plus vieille à la plus récente.
• journalctl -f (follow) affiche les lignes en continue (c'est l'équivalent de tail -f)
• journalctl --no-pager permet d'utiliser journalctl avec des filtres (comme grep, par exemple).

Le rand avantage de journald par rapport à syslog est sa possibilité de filtrer les logs par service

• journalctl -u service permet de lister les logs d'un service particulier.
• journalctl --list-boots permet de lister les démarrages de la machine

Comme pour rsyslog, les logs peuvent être centralisés.