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             # Liste tous les périphériques PCI (carte réseau, carte graphique, etc.)
lsusb             # Liste les périphériques USB

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

# Disques
lsblk              # blocs de stockage (disques et partitions)
lshw -short        # inventaire global du matériel

# 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    # messages du noyau
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 systemctl

# 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 (sans redémarrer)
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 "sale" 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 programmes dépendent d'autres programmes pour fonctionner. Un programme n'embarque pas l'intégralité de son code source, il utilise d'autres programmes (bibliothèques partagées).

Les bibliothèques partagées (.so, shared objects, équivalent des .dll sur Windows) é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
• Les fichiers de configuration : /etc/ld.so.conf et /etc/ld.so.conf.d/ indique au système l'emplacement des bibliothèques
• Le cache /etc/ld.so.cache accélère la recherche d'une bibliothèque

ldd /usr/bin/ls         # Bibliothèques utilisées par le programme (commande) ls
ldconfig                # Mettre à jour le cache après une installation manuelle
ldconfig -p             # Afficher le cache de toutes les bibliothèques connues du système

# variable d'environnement qui indique au chargeur dynamique où trouver les bibliothèques
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/mylib/lib # Ajout temporaire (durée d'une session)

# ajout persistante pour un utilisateur
echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/mylib/lib' >> ~/.bashrc
source ~/.bashrc # recharger

# ajout persistante pour le système (créer ou remplacer le fichier config)
sh -c 'echo /opt/mylib/lib > /etc/ld.so.conf.d/mylib.conf'
ldconfig

• 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 depuis les serveurs Debian
• dpkg (bas niveau) ne gère pas le réseau, installe un fichier local .deb déjà téléchargé

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

apt update                # mettre à jour la liste des paquets disponibles
apt upgrade               # mettre à jour le système
apt install paquet        # installer un paquet
apt remove paquet         # supprimer un paquet en gardant la config
apt purge paquet          # supprimer un paquet + fichiers de config
apt-cache search paquet   # rechercher dans tous les paquets Debian un paquet
apt show paquet

dpkg -i paquet.deb              # installer un paquet local .deb
dpkg -r paquet                  # supprimer
dpkg -l paquet                  # lister les paquets
dpkg -L paquet                  # lister les fichiers installés par un paquet
dpkg -S /chemin/fichier         # trouver à quel paquet appartient un fichier

Sur RHEL, Rocky Linux, 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 install paquet    # installer un paquet
dnf remove paquet     # supprimer un paquet
dnf check-update      # vérifier les MAJ dispos
dnf upgrade           # mettre à jour le système
dnf search paquet     # chercher un paquet
dnf info paquet       # infos d'un paquet

rpm -ivh paquet.rpm     # installer un paquet local (mode verbeux)
rpm -e paquet           # supprimer un paquet
rpm -qa                 # lister tous les paquets installés
rpm -ql httpd           # fichiers d'un paquet
rpm -qf /chemin/fichier # trouver à quel paquet appartient 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, etc.) 
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
!74                # rejouer la commande identifiée par le numéro 74 dans l'historique
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 identifiable pour un numéro
bg %1 ; fg %1             # arrière-plan / premier plan %1 fat reférence au job 1
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 un processus avec une priorité donnée
nice -n 10 ./traitement_lourd.sh

# Modifier la priorité d'un processus existant (déjà lancé)
renice -n 5 -p 1234
renice -n -5 -p 1234     # plus prioritaire (uniquement avec root)

# Afficher le processus 1234 avec uniquement les colonnes PID,NICE et CMD
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

# Mode commande
:w          enregistrer
:q          quitter
:wq         enregistrer + quitter
:q!         quitter sans enregistrer
:%s/a/b/g   remplacer partout
:set number afficher les lignes

## Mode normal
dd        supprimer une ligne
yy / p    copier / coller une ligne
/motif    rechercher
u         annuler

• Le modèle physique est la manière dont les données sont organisés par le matériel (disques). Les données sont organisées en bloc de taille fixe (souvent 4ko)
• Le modèle logique est la représentation par le système des données sans se préocupper du matériel (modèle physique)
Par exemple, un fichier de 18ko sur un disque avec des blocs de 4ko occupera 5 blocs
• Un système de fichiers est l'implémentation du modèle logique en s'appuyant sur :
  • Les inodes pour stocker les métadonnées (taille fichier, permissions, date de création, etc)
  • Les tables de répertoires (associer un nom de fichier à un inode)
  • Les superblocs (organisation du disque)

# voir les disques
lsblk
fdisk -l

# créer une partition (zone d'un disque)
fdisk /dev/sdb             # MBR
gdisk /dev/sdb             # GPT

# formater
mkfs.ext4 /dev/sdb1        # en ext4
mkfs.xfs  /dev/sdb2        # en xfs
mkswap /dev/sdb3 ; swapon /dev/sdb3  # en swap RAM virtuelle

blkid                      # UUID et type de FS des partitions
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 (ext2 et ext3 ancêtres de ext4)

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

# Voir les paramètres (attributs) d'un FS ext2/3/4
tune2fs -l /dev/sdb1      # Liste de tous les attributs
dumpe2fs /dev/sdb1        # Affiché également les attributs, détails du superbloc
# Modifier les Paramètres
tune2fs /dev/sdb1 -m 0    # Enlever le nombre de blocs resérvé à root (par défaut 5%)
tune2fs /dev/sdb1 -L docs # Associé un nom à cette partition
tune2fs /dev/sdb1 -i m    # Vérification mensuelle du FS

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 des fichiers des quotas pour utilisateurs et groupes
quotaon /home            # activer

edquota jean                        # éditer les quotas d'un utilisateur
setquota -u jean 500M 1G 0 0 /home  # ajout un quota
repquota /home                      # voir le rapport global
quota -u jean                       # voir le quota d'un utilisateur

Les permissions (droits) garantissent la sécurité et l'accès aux données

Principe fondamentale : chaque ressource appartient à un propriétaire (utilisateur ou système) et à un groupe (utilisateur ou système)

Chaque utilisateur possède un UID (User Identifier) et au moins un groupe principal GID (Group Idenfier)

Pour chaque ressource disponible (tout est fichier), il y a les droits de lecture, d'écriture et d'exécution pour :

• Propriétaire (créateur du contenu) noté u pour "user"
• Groupe propriétaire (utilisateurs qui sont dans le même groupe que le créateur) noté u pour "group"
• Les autres (tous les autres comptes utilisateurs ou système qui ne sont ni propriétaire, ni dans le groupe) noté o pour "others"

# Obtenir le UID et GUID de l'utilisateur courant  
id
id glodie
# Voir les permissions du fichier pour le propriétaire, le groupe et les autres
ls -l fichier.txt
-rw-r--r-- 1 user group 1024 fichier.txt

A chaque permission correspond

Ici : rw-r--r-- correspond au code 644.

Le propriétaire et root peuvent modifier les droits

# Modifier les droits
chmod 755 script.sh     # rwxr-xr-x (notation numérique (octal valeurs [0,7]) plus courte) 
                        # 1er chiffre propriétaire, 2ème groupe et 3ème autres
chmod u+x script.sh     # ajouter les droits d'exécution au propriétaire
chmod g-w fichier       # retirer l'écriture au groupe
chmod o-w fichier       # retirer l'écriture à tout le monde
chmod a=r               # lire pour tout le monde
chmod -R 750 dossier/   # récursif accordées à tous les sous-dossiers et fichiers de dossier/

# Modifier le propriétaire et le groupe
chown user:group fichier      # à effectuer par le propriétaire avec l'élévation des privilèges (sudo) ou root
chown -R user:group dossier/  # récursif

# Modifier uniquement le groupe
chgrp group dossier/

# Masque par défaut (permissions retirées)
## les 3 derniers chiffres sont significations pour déduire la valeur des droits par défaut
umask # retour 0022 → 777-022=755 pour dossiers, 666-022=644 pour fichiers  

Droit d'exécuter définit par 1 bit à la position 0, si le droit est accordé 1*2^0 donc 1

Droit d'écrire définit par 1 bit à la position 1, le droit est accordé 1*2^1 donc 2

Droit le lecture définit par 1 bit à la position 2, 1*2^2 donc 4

Avec SetUID on utilise (empreinte) les droits de son propriétaire

SetGID on empreinte les droits du groupe propriétaire

StickyBit permet de gérer les droits sur les dossiers partagées

chmod 4755 /usr/bin/prog   # SUID, le droit d'exécution x du propriétaire est remplacé par la lettre s
chmod 2775 /partage        # SGID, x de groupe remplacé par s
chmod 1777 /tmp            # Sticky bit, x des autres comptent est remplacé par T

Pour créer un utilisateur adduser (haut niveau interactive) ou useradd(bas niveau)

Pour créer un groupe addgroup ou groupadd

Pour modifier les privilèges des utilisateurs et des groupes usermod et groupmod

Pour aller plus loin avec les droits, il y a ACL (Access Control List) avec plus de granularité (affinage). cf articles de François-Emmanuel Goffinet et Stéphane Robert

Les liens symboliques permettent de

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

# Lien physique
ln fichier.txt lien_dur

# Afficher les liens
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