Linux découvre le matériel via le noyau et ses modules (pilotes), puis l'expose dans les pseudo-systèmes de fichiers /proc et /sys, alimentés en continu par le gestionnaire de périphériques udev.

• Le noyau charge un module pour chaque matériel détecté
• /proc : informations sur le système et les processus en temps réel
• /sys : représentation des périphériques et de leurs attributs
• udev : crée les nœuds de périphériques dans /dev

# Bus PCI et USB
lspci
lsusb

# CPU et mémoire
lscpu
free -h
cat /proc/cpuinfo
cat /proc/meminfo

# Disques et périphériques bloc
lsblk
lshw -short        # vue d'ensemble (root)

# Modules chargés et détails
lsmod # lit le fichier /proc/modules pour afficher les modules actifs du noyau et leurs dépendances
modinfo e1000e

# Charger / décharger un pilote
modprobe e1000e
modprobe -r e1000e

# Détection matérielle au fil de l'eau
dmesg | less
dmesg | grep -i usb

Configuration persistante : /etc/modules-load.d/*.conf (chargement) et /etc/modprobe.d/*.conf (options).

Du bouton d'alimentation à l'invite de connexion, le démarrage suit toujours les mêmes étapes :

• BIOS/UEFI : test matériel (POST), puis cherche un disque amorçable
• GRUB : charge le noyau et l'initramfs (initial RAM filesystem) dont le rôle est de fournir les pilotes et scripts pour monter le système de fichiers racine
• Noyau : initialise le matériel et monte la racine
• systemd (PID 1) : lance les services jusqu'à la cible voulue. Le pilotage ce processus s'effectue à travers sytemctl

# Messages du noyau
dmesg

# Journaux de démarrage
journalctl -b            # boot courant
journalctl -b -1         # boot précédent
journalctl -p err -b     # erreurs uniquement

# Temps de démarrage
systemd-analyze
systemd-analyze blame    # services les plus lents

Les anciens runlevels SysVinit (ancien système d'initialisation via des scripts dans /etc/init.d) sont remplacés par les targets de systemd.

# Cible par défaut au démarrage
systemctl get-default                       # obtenir la cible par défaut
systemctl set-default multi-user.target     # définir par défaut le mode texte
# État du système
systemctl is-system-running                 # running ou degraded => mode normal, maintenance => mode rescue
# Basculer de cible à chaud
systemctl isolate rescue.target             # mode maintenance
systemctl isolate graphical.target          # mode graphique

# Arrêt propre du système avec shutdown (broadcast à tous les utilisateurs connectées)
shutdown -h now                                   # arrêt immédiat
shutdown -r +10                                   # redémarrage dans 10 min
shutdown 22:30 "Maintenance prévue à 22h30"       # arrêt prévue à 22:30
shutdown -c                                       # annuler un arrêt programmé

# Arrêt "salle" sans prévenir
reboot
poweroff
halt

# Prévenir les utilisateurs connectés
wall "Arrêt du serveur dans 5 minutes" 

• Séparer le système des données utilisateur
• Limiter l'impact d'un disque plein en isolant /var
• Faciliter sauvegardes et réinstallations
• Appliquer des options de montage spécifiques (noexec, nosuid)

Pour partionner un disque, il faut

• Lister les disques avec lsblk ou fdisk -l ou ls -l /dev/sd*
• Définir la taille de la partition avec un gestionnaire de partition (fdisk, gdisk, parted)
• Formater la partition en installant un système de fichier (EXT4, NTFS, FAT32, etc.) avec les outils de formatage (mkfs, fstab)
• Monter la partition dans un repertoire pour stocker des données avec les outils de montage (mount, umount(démontage))
  • Editer le fichier /etc/fstab pour effectuer le montage au démarrage
  • Monter toutes les partitions avec mount -a

#  Table de partition = annuaire du disque

# Lister disques et partitions
lsblk # ou fdisk -l

# Gestionnaires de partitions
##  mode MBR ancien standard Master Boot Record, supporte aussi GPT, 4 partitions primaires max
##  idéal pour les clés USB et disques ≤ 2 To
fdisk /dev/sdb

##  mode GPT nouveau standard UEFI/GPT pour les disques et installations modernes
##  jusqu'à 128 partitions
gdisk /dev/sdb

##  modes MBR et GPT : temps réel, tout est faisable en une ligne de commande
##  idéal pour des scripts automatisés
parted /dev/sdb

• GRUB (GRand Unified Bootloader) : le standard actuel
• Permet de choisir le noyau ou l'OS au démarrage
• Configuration générée : /boot/grub/grub.cfg (ne pas éditer à la main)
• Fichier de configuration : /etc/default/grub

Historique : LILO (Linux Loader), aujourd'hui obsolète.

# Installer GRUB sur un disque (BIOS)
grub-install /dev/sda

# Régénérer la configuration
update-grub                              # Debian / Ubuntu
grub-mkconfig -o /boot/grub/grub.cfg     # générique

# /etc/default/grub
## Options disponibles depuis /etc/default/grub
GRUB_DEFAULT=0
GRUB_TIMEOUT=5
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"

# Pour appliquer les modifications
update-grub

En UEFI, GRUB s'installe dans la partition EFI (/boot/efi).

Les bibliothèques partagées (.so, shared objects) évitent de dupliquer le même code dans chaque programme : il est chargé une fois en mémoire et réutilisé.

• Le chargeur dynamique ld.so résout les bibliothèques au lancement
• Le cache /etc/ld.so.cache accélère leur localisation
• Chemins de recherche : /etc/ld.so.conf et /etc/ld.so.conf.d/

# Bibliothèques utilisées par un programme
ldd /usr/bin/ls

# Mettre à jour le cache
ldconfig
ldconfig -p            # afficher le cache

# Ajouter un répertoire (temporaire)
export LD_LIBRARY_PATH=/opt/mylib/lib

• Préférer l'ajout d'un fichier dans /etc/ld.so.conf.d/ puis ldconfig plutôt que LD_LIBRARY_PATH
• Une bibliothèque manquante se voit avec ldd (mention not found)
• Le numéro de version (libfoo.so.1) gère la compatibilité binaire

Sous Debian/Ubuntu, deux niveaux d'outils cohabitent :

• apt (haut niveau) : gère les dépôts et résout les dépendances
• dpkg (bas niveau) : installe un fichier .deb unique

Dépôts : /etc/apt/sources.list et /etc/apt/sources.list.d/

apt update              # rafraîchir l'index des dépôts
apt upgrade             # mettre à jour les paquets
apt install nginx       # installation du paquet
apt remove nginx        # suppression du paquet
apt purge nginx         # suppression du paquet + fichiers de config
apt-cache search nginx  # recherche de tous les paquets avec le nom nginx
apt show nginx

dpkg -i paquet.deb      # installer un .deb
dpkg -r paquet          # supprimer
dpkg -l                 # lister les paquets
dpkg -L nginx           # fichiers d'un paquet
dpkg -S /etc/nginx/nginx.conf   # paquet d'un fichier

Sur RHEL, Rocky, Fedora… on retrouve la même logique à deux niveaux :

• dnf (successeur de yum) : dépôts + dépendances
• rpm : un paquet .rpm à la fois

Dépôts : /etc/yum.repos.d/*.repo

dnf check-update
dnf upgrade
dnf install httpd
dnf remove httpd
dnf search httpd
dnf info httpd
dnf list installed

rpm -ivh paquet.rpm     # installer (verbeux)
rpm -e paquet           # supprimer
rpm -qa                 # lister tout
rpm -ql httpd           # fichiers d'un paquet
rpm -qf /etc/httpd/conf/httpd.conf   # paquet d'un fichier

Le shell (Bash par défaut) interprète les commandes saisies.

• Commande interne : intégrée au shell (cd, echo, pwd)
• Commande externe : programme situé dans le $PATH
• Alias : raccourci personnel pour une commande

#  Nature de la commande avec type
## builtin = commande intégrée au shell (commande interne)
## alias, function shell, file (exécutable), keyword (mot-clé réservé par le shell ex: if, then, for, case) 
type cd            # builtin
type ls            # /usr/bin/ls

which python3      # localiser un exécutable

alias ll='ls -la'   # création d'alias depuis le fichier .bashrc

echo $HOME         # répertoire personnel
echo $USER         # utilisateur courant
echo $PATH         # chemins de recherche
echo $SHELL        # shell utilisé

MA_VAR="bonjour"
export MA_VAR      # visible aux sous-processus
env                # tout l'environnement

man ls             # manuel d'utilisation de la commande ls
man 5 passwd       # section 5 (formats de fichier)
ls --help          # aide rapide sur l'utilisation et les options de la commande ls


history            # historique des commandes
!!                 # rejouer la dernière
Ctrl + r           # recherche dans l'historique

Un filtre lit sur l'entrée standard, transforme le texte, et écrit sur la sortie standard. On les enchaîne avec des pipes.

head -n 5 /etc/passwd         # afficher les premières lignes
tail -f /var/log/syslog       # suivi en direct
wc -l fichier.txt             # nombre de lignes

sort fichier.txt | uniq       # tri et suprression des doublons
sort -n nombres.txt           # tri numérique
cut -d: -f1,7 /etc/passwd     # colonnes 1 et 7
echo "linux" | tr 'a-z' 'A-Z' # -> LINUX

Combinés, les filtres répondent à des questions concrètes :

# Top 10 des IP dans un log d'accès
cut -d' ' -f1 access.log | sort | uniq -c | sort -rn | head

# Écrire à l'écran ET dans un fichier
ls /etc | tee liste.txt

pwd                # où suis-je ?
cd /etc ; cd .. ; cd ~  # se déplacer dans le dossier /etc, revenir dans le dossier parent

ls -l              # détaillé
ls -la             # + fichiers cachés
ls -lh             # tailles plus facilement lisibles pour nous (humains)
ls -lt             # tri par date

mkdir -p projet/src       # création des dossiers projet et projet/src
touch fichier.txt         # créer le fichier.txt
cp fichier.txt copie.txt  # copier et le renommer le fichier
cp -r dossier/ sauvegarde/  # copier les dossiers et leurs contenus (sous-dossiers et fichiers)  
mv ancien.txt nouveau.txt # renommer ou déplacer, ici le renommage
mv nouveau.txt /tmp # déplacer le fichier
rm fichier.txt # supprimer le fichier
rm -r dossier/            # suppression récursive du dossier et de son contenu

file image.png            # type réel d'un fichier
stat fichier.txt          # métadonnées détaillées

ls *.txt                  # joker : tout ce qui finit en .txt
ls fichier.jpe?g           # ? = un seul caractère faculative 0 ou 1 occurrence
ls [abc]*.log             # classe de caractères, contient a, b ou c

Le « globbing » (expansion des motifs) est résolu par le shell avant l'exécution de la commande.

Chaque commande dispose de trois flux standard :

Le pipe | branche le stdout d'une commande sur le stdin de la suivante.

ls /etc > liste.txt          # écrase le contenu du fichier liste.txt
echo "ligne" >> liste.txt    # ajoute à la fin (conserve le contenu du fichier)
ls /inexistant 2> erreurs.txt  # rediriger stderr
commande > sortie.txt 2>&1   # stdout et stderr
wc -l < liste.txt            # entrée depuis un fichier

ls /etc | wc -l              # compter les fichiers
ps aux | grep nginx          # filtrer une liste
cat f.txt | sort | uniq      # chaîner plusieurs filtres
ls -la /etc | less           # paginer un résultat long

• Chaque programme lancé est un processus
• Identifié par un PID (Process ID)
• Rattaché à un parent par son PPID
• systemd (PID 1) est l'ancêtre de tous les processus

ps aux             # tous les processus
ps -ef             # format complet
ps -p 1088 -o ppid,pid,stat,%cpu,%mem # affichage du processus 1088 avec quelques colonnes
pstree             # arborescence (processus sous forme d'arbre)
top                # temps réel
htop               # version améliorée du temps réel
free -h            # mémoire

./script.sh &      # lancer le script en arrière-plan
Ctrl + Z           # suspendre
jobs               # lister les jobs
bg %1 ; fg %1      # arrière-plan / premier plan
nohup ./script.sh &  # survit à la déconnexion

kill 1234          # SIGTERM (propre)
kill -9 1234       # SIGKILL (forcé)
killall nginx ; pkill -f script.sh

La priorité d'ordonnancement se règle via la niceness (NI), de −20 (prioritaire) à +19 (peu prioritaire). Défaut : 0.

Plus la valeur est élévée, plus le processus est gentil car il laisse la place aux autres d'utiliser les ressources.

Tous les utilisateurs peuvent modifier à la baisse, seul root peut modifier à la hausse

# Lancer avec une priorité donnée
nice -n 10 ./traitement_lourd.sh

# Modifier un processus existant
renice -n 5 -p 1234
renice -n -5 -p 1234     # plus prioritaire (root)

# Voir la colonne NI
ps -o pid,ni,cmd -p 1234

• Seul root peut attribuer une valeur négative
• Une priorité basse libère du CPU pour les tâches interactives
• top permet de modifier la niceness à chaud (touche r)
• À ne pas confondre avec la priorité temps réel (chrt)

grep recherche les lignes correspondant à un motif (expression rationnelle).

grep "root" /etc/passwd
grep -i "error" syslog      # insensible à la casse
grep -n "TODO" main.c       # numéros de ligne
grep -r "clé" ./src         # récursif
grep -v "^#" sshd_config    # exclure les commentaires
grep -c "404" access.log    # compter

# -E active +, ?, |, {} sans échappement
grep -E "^[a-z]+@[a-z]+\.[a-z]{2,}$" emails.txt

grep -E "warn|error|fatal" app.log
grep -Eo "[0-9]{1,3}(\.[0-9]{1,3}){3}" access.log  # IPv4

-o n'affiche que la partie qui correspond ; egrep équivaut à grep -E.

• Présent sur toutes les distributions
• Fonctionne en terminal, sans interface graphique
• Incontournable pour éditer un fichier de config sur un serveur

:w        enregistrer
:q        quitter
:wq       enregistrer + quitter
:q!       quitter sans enregistrer

dd        supprimer une ligne
yy / p    copier / coller une ligne
/motif    rechercher
:%s/a/b/g  remplacer partout
u         annuler

Une partition est une zone du disque ; un système de fichiers est la structure qui y organise les données.

lsblk ; fdisk -l           # voir les disques

fdisk /dev/sdb             # créer une partition (MBR)
gdisk /dev/sdb             # GPT

mkfs.ext4 /dev/sdb1        # formater en ext4
mkfs.xfs  /dev/sdb2        # ou en xfs
mkswap /dev/sdb3 ; swapon /dev/sdb3

blkid                      # UUID et type de FS
lsblk -f                   # arbre disques + FS
df -hT                     # FS montés + type

L'UUID identifie une partition de façon stable, indépendamment de l'ordre des disques.

df -h              # espace par système de fichiers
df -i              # inodes (nombre de fichiers)
du -sh /var        # taille d'un répertoire
du -sh * | sort -h # classer les sous-dossiers

# TOUJOURS sur un FS démonté
umount /dev/sdb1
fsck /dev/sdb1
e2fsck -f /dev/sdb1     # forcer (ext2/3/4)

Ne jamais lancer fsck sur un système de fichiers monté et actif : risque de corruption.

tune2fs -l /dev/sdb1    # paramètres du FS
dumpe2fs /dev/sdb1      # détails du superbloc

# Forcer une vérification au prochain boot
tune2fs -c 30 /dev/sdb1 # tous les 30 montages

Sous Linux, un système de fichiers n'a pas de lettre de lecteur : il est monté dans un répertoire (point de montage) de l'arborescence unique.

mount /dev/sdb1 /mnt/data   # monter
mount                       # voir les montages
umount /mnt/data            # démonter
umount /dev/sdb1            # par périphérique

# <FS>           <point>   <type> <options>  <dump> <pass>
UUID=xxxx-xxxx   /mnt/data  ext4   defaults   0      2

mount -a           # monter tout ce qui est dans fstab

Référencer par UUID (obtenu via blkid) évite les erreurs si l'ordre des disques change.

Les quotas limitent, par utilisateur ou par groupe, l'espace (blocs) et le nombre de fichiers (inodes) sur un système de fichiers.

• Empêche un utilisateur de saturer /home
• Distingue limite souple (avertissement) et dure (blocage)

# /etc/fstab : ajouter les options de quotas
/dev/sdb1  /home  ext4  defaults,usrquota,grpquota  0 2

mount -o remount /home
quotacheck -cug /home    # initialiser
quotaon /home            # activer

edquota jean        # éditer les quotas d'un utilisateur
setquota -u jean 500M 1G 0 0 /home

repquota /home      # rapport global
quota -u jean       # quota d'un utilisateur

ls -l fichier.txt
-rw-r--r-- 1 user group 1024 fichier.txt

Ici : rw-r--r-- = 644.

chmod 755 script.sh     # rwxr-xr-x (octal)
chmod u+x script.sh     # symbolique : +exec owner
chmod g-w fichier       # retirer écriture au groupe
chmod -R 750 dossier/   # récursif

chown user:group fichier
chown -R user:group dossier/
umask                   # masque par défaut (0022)

chmod 4755 /usr/bin/prog   # SUID
chmod 2775 /partage        # SGID
chmod 1777 /tmp            # sticky bit

# Lien symbolique (raccourci)
ln -s /chemin/vers/cible lien_symbo

# Lien physique
ln fichier.txt lien_dur

ls -l            # un symlink s'affiche  lien -> cible
ls -i fichier    # voir le numéro d'inode

• Symlink : exposer une version (python -> python3.11)
• Symlink : activer un service web (sites-enabled/ → sites-available/)
• Hard link : sauvegardes économes (mêmes données, plusieurs noms)

# find : recherche en temps réel, très puissante
find /etc -name "*.conf"
find /home -type f -size +100M
find /var/log -mtime +30 -delete
find . -type f -perm 644

# locate : base indexée, très rapide
updatedb            # mettre à jour l'index (root)
locate sshd_config

which python3       # exécutable dans le PATH
whereis ls          # binaire + sources + man
type cd             # interne ou externe ?

Le FHS (Filesystem Hierarchy Standard) dit où placer chaque type de fichier.

FHS maintenu par la fondation Linux et normalise les répertoires dans toutes les distributions