# 1-Shell #

Modification du fichier /etc/passwd la section shell en

**`/usr/bin/nologin`** ou **`/dev/zero`** ou encore **`/dev/null`** :L'utilisateur
ne peut pas interpreter la moindre commande .

# 2-Exemple de configuration #

Bien sûr ! La chaîne que vous avez affichée avec `echo $PS1` est une configuration
de l'invite de commande (prompt) dans un shell Unix/Linux, probablement Bash. Elle
définit comment votre terminal affiche l'invite, avec des informations comme le nom
d'utilisateur, le nom de la machine, et le répertoire de travail, agrémentés de
couleurs et de formatages. Décomposons cela étape par étape :

### La chaîne complète :

```
\[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\
033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$
```

#### 1. **`\[\e]0;\u@\h: \w\a\]`**

- `\[\` et `\]` : Ces délimiteurs indiquent que ce qui est à l'intérieur est une
séquence non imprimable (comme des codes de contrôle ou des couleurs). Cela permet
au shell de ne pas compter ces caractères dans la longueur de l'invite, évitant des
problèmes d'affichage.
- `\e]0;` : C'est une séquence d'échappement (Escape, `\e`, équivalent à `\033` ou
`ESC`) qui commence une commande pour définir le titre de la fenêtre du terminal
(souvent visible dans l'onglet ou la barre de titre).
- `\u@\h: \w` :
- `\u` : Nom de l'utilisateur actuel (par exemple, `m-mampionontsoa`).
- `@` : Le caractère littéral "@".
- `\h` : Nom de la machine (hostname, ici `m-mampionontsoa-HP-EliteBook-820-G2`).
- `: ` : Deux caractères littéraux, un deux-points et un espace.
- `\w` : Chemin du répertoire de travail actuel (par exemple, `~/` ou `/home/m-
mampionontsoa`).
- `\a` : Caractère ASCII "bell" (code 7), qui termine la séquence de titre dans
certains terminaux (bien que son effet soit souvent ignoré aujourd'hui).

**Résultat** : Cette partie définit le titre de la fenêtre du terminal comme

quelque chose comme `m-mampionontsoa@m-mampionontsoa-HP-EliteBook-820-G2: ~/`.

---

#### 2. **`${debian_chroot:+($debian_chroot)}`**
- `${variable:+valeur}` : C'est une substitution conditionnelle en Bash. Si la
variable `debian_chroot` est définie et non vide, alors la valeur entre parenthèses
`($debian_chroot)` est insérée.
- `debian_chroot` : Une variable souvent utilisée dans les environnements
Debian/Ubuntu pour indiquer que vous êtes dans un environnement chroot (un sous-
système isolé). Si elle n'est pas définie, cette partie n'apparaît pas.
- `($debian_chroot)` : Si la variable est définie, elle sera affichée entre
parenthèses.

**Résultat** : Si vous êtes dans un chroot nommé, par exemple, "monchroot", cela
affichera `(monchroot)` au début de l'invite. Sinon, rien ne s'affiche.

---
#### 3. **`\[\033[01;32m\]\u@\h\[\033[00m\]`**
- `\[\033[01;32m\]` : Une séquence d'échappement pour définir la couleur et le
style du texte :
- `\033` : Code d'échappement (Escape).
- `[01;32m` :
- `01` : Texte en gras (bold).
- `32` : Couleur verte.
- Résultat : Le texte suivant sera affiché en vert gras.
- `\u@\h` : Comme avant, le nom d'utilisateur (`\u`), suivi de "@", suivi du nom de
la machine (`\h`).
- `\[\033[00m\]` : Réinitialise les attributs de couleur et de style (retour à la
normale, texte non coloré).

**Résultat** : Affiche `m-mampionontsoa@m-mampionontsoa-HP-EliteBook-820-G2` en

vert gras.

---

#### 4. **`:\[\033[01;34m\]\w\[\033[00m\]`**
- `:` : Le caractère littéral deux-points, qui sépare le nom d'utilisateur/machine
du chemin.
- `\[\033[01;34m\]` : Nouvelle séquence de couleur :
- `01` : Texte en gras.
- `34` : Couleur bleue.
- Résultat : Le texte suivant sera en bleu gras.
- `\w` : Chemin du répertoire de travail actuel.
- `\[\033[00m\]` : Réinitialise la couleur et le style.

**Résultat** : Affiche le chemin (par exemple, `~/` ou `/home/m-mampionontsoa`) en

bleu gras.

---

#### 5. **`\$`**
- `\$` : Affiche un caractère spécial selon votre identité :
- Si vous êtes un utilisateur normal, cela affiche `$`.
- Si vous êtes root (superutilisateur), cela affiche `#`.
- C'est une convention pour indiquer visuellement si vous avez des privilèges
élevés.

**Résultat** : Dans votre cas, comme vous êtes probablement un utilisateur normal,
cela affiche `$`.

---

### Mise en forme finale

En combinant tout cela, votre invite ressemble à ceci dans le terminal :
```
m-mampionontsoa@m-mampionontsoa-HP-EliteBook-820-G2:~/$
```
- `m-mampionontsoa@m-mampionontsoa-HP-EliteBook-820-G2` en vert gras.
- `:` en couleur normale (blanche ou par défaut).
- `~/` en bleu gras.
- `$` en couleur normale.

Si vous êtes dans un chroot nommé "monchroot", cela deviendrait :

```
(monchroot)m-mampionontsoa@m-mampionontsoa-HP-EliteBook-820-G2:~/$
```
### Pourquoi ces couleurs et ce format ?
Cette configuration est typique des distributions Linux comme Debian ou Ubuntu. Les
couleurs aident à distinguer visuellement les différentes parties de l'invite
(utilisateur/machine vs chemin), et le titre de la fenêtre est utile dans les
environnements avec plusieurs terminaux ouverts.

Si vous avez d'autres questions ou voulez personnaliser cela, n’hésitez pas à

demander !

# 2-Arborescence de Fichier Linux #

Dans l’arborescence Linux, les concepts de répertoires **"sharable"**

(partageables), **"unsharable"** (non partageables) et **"static"** (statiques) ou
**"variable"** proviennent principalement du **Filesystem Hierarchy Standard
(FHS)**, qui définit une organisation standard des fichiers et répertoires dans les
systèmes Unix-like, comme Linux. Ces notions aident à structurer le système de
fichiers pour faciliter la gestion, le partage entre machines, et la maintenance.
Voici une explication détaillée :

---

### 1. **Sharable vs Unsharable**

Ces termes distinguent les répertoires selon qu’ils peuvent être partagés entre
plusieurs systèmes (par exemple, via un montage réseau comme NFS) ou qu’ils sont
spécifiques à une machine locale.

- **Sharable (partageable)** :
- Ce sont des répertoires dont le contenu peut être utilisé par plusieurs hôtes
sans causer de conflits ou nécessiter de modifications locales.
- Exemples :
- **/usr** : Contient des binaires, bibliothèques et données en lecture seule
(comme `/usr/bin`, `/usr/lib`) qui peuvent être montés en lecture seule sur
plusieurs machines.
- **/home** : Contient les répertoires personnels des utilisateurs, qui peuvent
être partagés via un serveur centralisé (par exemple, dans un environnement réseau
avec NFS).
- Avantage : Ces répertoires peuvent être placés sur un disque réseau et
accessibles à distance, réduisant la duplication.

- **Unsharable (non partageable)** :

- Ce sont des répertoires spécifiques à une machine donnée, car leur contenu
dépend du système local ou change en fonction de son état.
- Exemples :
- **/etc** : Contient les fichiers de configuration spécifiques à la machine
(comme `/etc/hostname`, `/etc/passwd`).
- **/var** : Contient des données variables propres au système, comme les
fichiers de log (`/var/log`) ou les verrous (`/var/lock`).
- **/boot** : Contient les fichiers nécessaires au démarrage de cette machine
spécifique (comme le noyau Linux ou le chargeur de démarrage).
- Particularité : Ces répertoires ne peuvent pas être partagés facilement, car
leur contenu est unique à chaque système.

---

### 2. **Static vs Variable**

Cette distinction concerne la nature des fichiers : changent-ils fréquemment ou
restent-ils stables sans intervention explicite ?
- **Static (statique)** :
- Ces répertoires contiennent des fichiers qui ne changent pas sans une action
explicite de l’administrateur système (comme une mise à jour ou une installation).
- Exemples :
- **/usr** : Les binaires et bibliothèques installés (par exemple,
`/usr/bin/ls`) sont statiques ; ils ne changent pas pendant l’exécution normale du
système.
- **/opt** : Logiciels tiers installés manuellement, qui restent inchangés
jusqu’à une mise à jour.
- Avantage : Ces répertoires peuvent être montés en lecture seule, car ils n’ont
pas besoin d’être modifiés dynamiquement.

- **Variable (variable)** :
- Ces répertoires contiennent des fichiers qui changent fréquemment, souvent sans
intervention manuelle, en raison de l’activité du système ou des utilisateurs.
- Exemples :
- **/var** : Logs (`/var/log`), files d’attente de courriel (`/var/spool`), ou
fichiers temporaires (`/var/tmp`).
- **/tmp** : Fichiers temporaires créés et supprimés dynamiquement.
- Particularité : Ces répertoires nécessitent un accès en écriture et sont
souvent exclus des sauvegardes fréquentes, car leur contenu est éphémère ou
spécifique à l’état actuel du système.

---

### 3. **Pourquoi cette organisation ?**

Ces distinctions permettent de :
- **Optimiser le stockage** : Les répertoires "sharable" et "static" comme `/usr`
peuvent être montés en lecture seule sur un serveur centralisé, économisant de
l’espace sur les machines clientes.
- **Faciliter les sauvegardes** : Les répertoires "static" nécessitent des
sauvegardes moins fréquentes, tandis que les répertoires "variable" comme `/var`
doivent être surveillés plus souvent.
- **Sécuriser le système** : Les répertoires "unsharable" comme `/etc` restent
locaux pour éviter des conflits ou des corruptions dans un environnement multi-
machines.

---

### 4. **Exemples dans l’arborescence Linux**

Voici comment ces concepts s’appliquent aux répertoires principaux :
- **/usr** : Sharable et Static (binaires et données en lecture seule, partageables
entre machines).
- **/home** : Sharable et Variable (données utilisateur partageables, mais
modifiables par les utilisateurs).
- **/etc** : Unsharable et Static (configurations locales, modifiées uniquement par
l’administrateur).
- **/var** : Unsharable et Variable (données dynamiques spécifiques à la machine).
- **/boot** : Unsharable et Static (fichiers de démarrage propres à la machine).

---

### 5. **Application pratique**

Imaginez un réseau d’entreprise :
- Vous montez `/usr` depuis un serveur central en lecture seule (sharable, static).
- Vous laissez `/etc` et `/boot` sur chaque machine locale (unsharable, static).
- Vous stockez les logs dans `/var/log` sur chaque machine (unsharable, variable).
- Vous partagez `/home` via NFS pour que les utilisateurs accèdent à leurs fichiers
depuis n’importe quelle machine (sharable, variable).
---

En résumé, dans l’arborescence Linux, "sharable" et "unsharable" définissent si un

répertoire peut être partagé entre systèmes, tandis que "static" et "variable"
indiquent si son contenu change dynamiquement. Ces concepts guident la gestion des
fichiers et l’architecture des systèmes Linux, surtout dans des environnements
multi-machines. Si vous avez une question spécifique sur un répertoire, n’hésitez
pas à demander !

## Les Principaux répertoire de l'arborescence ##

#### **Le répertoire `/usr`**

- **`/usr/bin`**: ce répertoire contient majoritairement les commandes à

destination de tous les utilisateurs du système, privilégiés ou non.

- **`/usr/sbin`**: ce sont des commandes à nouveau à destination unique de

l'administrateur, mais non critiques pour le bon fonctionnement du système.
- **`/usr/local/bin`** :! Ce dernier de la famille va contenir tous les binaires
qui sont compilés manuellement par l'administrateur après l'installation du
système.
- - **/usr/lib** : Bibliothèques partagées utilisées par les programmes dans
/usr/bin et /usr/sbin (ex. [Link]).
- **/usr/share** : Données statiques indépendantes de l’architecture, comme la
documentation (/usr/share/doc) ou les fichiers de configuration par défaut.
- **/usr/include** : Fichiers d’en-tête (headers) pour la compilation de programmes
en C/C++

Le répertoire **`/usr`** est très important, il est marqué "**shareable**" et

"**static**", ce qui implique que d'un système à l'autre, les éléments contenus
dans ce répertoire sont censés fonctionner exactement de la même manière.

## **Le répertoire `/var`**

L'objectif de ce répertoire est simple : stocker toutes les informations

utilisateurs, administrateurs et systèmes **variables**.

Il y a quelques sous-répertoires de**`/var`** qu'il est important de mentionner :

- **`/var/log`**: répertoire contenant l'arborescence de toutes les traces systèmes

et applicatives. C'est dans ce répertoire qu'il est possible de consulter les
traces des historiques de démarrage du système, de connexion des comptes
utilisateurs, d'activité des services réseaux (SSH, HTTPD, SMTP, etc.) ainsi que
les traces du noyau. Généralement les applications installées sur le système
disposent de leur propre sous-répertoire (**`/var/log/apache2`**par exemple).

- **`/var/run`**: répertoire contenant toutes les données relatives aux processus

en cours d'exécution, les sémaphores, les données applicatives, les fichiers numéro
de processus, etc.

- **`/var/spool`**: répertoire contenant des données stockées de manière temporaire

entre processus. Souvent, ce répertoire est utilisé pour stocker des données
relatives à des actions ou tâches à effectuer dans un futur proche par les
processus en cours d'exécution.

## Autre Répertoire de l'arborescence de Linux ##

- **`/var/mail`**: c'est le répertoire de stockage des messageries électroniques
locales des comptes utilisateurs du système

- **/** (racine) : Point de départ de l’arborescence, contient les répertoires de

niveau supérieur.
- **/bin** : Binaires essentiels pour tous les utilisateurs, disponibles même en
mode de récupération (ex. bash, cp).
- **/sbin** : Binaires essentiels pour l’administrateur, nécessaires au démarrage
ou à la réparation (ex. fsck, reboot).
- **/etc** : Fichiers de configuration spécifiques au système (unsharable, static).
- **/home** : Répertoires personnels des utilisateurs (sharable, variable).
- **/tmp** : Fichiers temporaires volatils (variable, souvent en RAM via tmpfs).
- **/boot** : Fichiers de démarrage (unsharable, static).
- **/dev** : Fichiers représentant les périphériques (variable, unsharable).
- **/proc** : Système de fichiers virtuel reflétant l’état du noyau et des
processus (variable, unsharable).

---

### **Conclusion**

Vous avez bien cerné /usr et /var, et effectivement, il y a d’autres sous-

répertoires dans /var (comme /var/tmp, /var/cache, /var/lib) et d’autres
répertoires majeurs dans l’arborescence Linux. Chaque répertoire a un rôle
spécifique, et les notions de "sharable/unsharable" et "static/variable" aident à
comprendre leur usage dans des contextes locaux ou distribués. Si vous voulez
approfondir un répertoire particulier ou un cas d’utilisation, faites-le-moi savoir
!

## Système de Fichier Virtuel de Linux ##

#### **Le répertoire `/proc`** ###

Cette arborescence contient toutes les informations concernant le processus !

Ces fichiers sont intéressants à relever dans cette arborescence :

- **`/proc/version`** contient la version exacte du noyau en exécution,

- **`/proc/meminfo`**, les informations détaillés sur la mémoire vive gérée par le

noyau,

- **`/proc/uptime`**, le temps d'exécution cumulé,

- **`/proc/cmdline`**, les paramètres passés au démarrage du noyau, etc.

- ` ** /proc/cpuinfo ** ` contient les informations sur le(s) processeur(s)
maintenues par le noyau.

Les **systèmes de fichiers virtuels** sous Linux jouent un rôle essentiel dans la
gestion et l’interaction avec le système d’exploitation. Contrairement aux systèmes
de fichiers classiques (comme `ext4`, `NTFS` ou `FAT`), qui stockent des données
physiques sur un disque, les systèmes de fichiers virtuels sont des abstractions
maintenues en mémoire par le noyau Linux. Ils ne reposent pas sur un stockage
persistant, mais fournissent une interface dynamique pour accéder à des
informations sur le système, les processus, ou le matériel. Voici une explication
détaillée de leur rôle, accompagnée des exemples les plus courants :
---

### **Rôle des systèmes de fichiers virtuels**

1. **Fournir une interface utilisateur au noyau** :
- Ils permettent aux utilisateurs et aux programmes d’interagir avec le noyau
Linux sans avoir à écrire du code bas niveau. Les données sont présentées sous
forme de fichiers et de répertoires, accessibles avec des commandes standards comme
`cat`, `ls`, ou `echo`.

2. **Refléter l’état du système en temps réel** :

- Ces systèmes exposent des informations dynamiques (comme l’utilisation CPU, la
mémoire, ou les processus en cours) qui changent constamment, sans nécessiter de
stockage physique.

3. **Faciliter la gestion des ressources** :

- Ils offrent un moyen de contrôler ou de surveiller le matériel, les processus,
et les paramètres du système via des fichiers spéciaux.

4. **Améliorer la portabilité et la modularité** :

- En utilisant une interface fichier, les systèmes de fichiers virtuels
standardisent l’accès aux fonctionnalités du noyau, rendant les scripts et les
applications plus portables entre différentes distributions Linux.

---

### **Principaux systèmes de fichiers virtuels sous Linux**

Voici les exemples les plus courants et leur rôle spécifique :

#### 1. **`/proc` : Informations sur les processus et le noyau**

- **Rôle** : Fournit une vue en temps réel des processus en cours et des paramètres
du noyau.
- **Caractéristiques** :
- Chaque processus en exécution a un sous-répertoire nommé d’après son PID (par
exemple, `/proc/1234` pour le processus avec l’ID 1234).
- Contient des fichiers comme :
- `/proc/cpuinfo` : Informations sur le processeur.
- `/proc/meminfo` : Détails sur l’utilisation de la mémoire.
- `/proc/uptime` : Temps depuis le démarrage du système.
- `/proc/sys/` : Paramètres configurables du noyau (ex.
`/proc/sys/kernel/hostname` pour le nom de la machine).
- **Exemple d’utilisation** :
```bash
cat /proc/cpuinfo
```
Affiche les détails du CPU.

- **Nature** : Variable et unsharable (spécifique à chaque système et en constante

évolution).

#### 2. **`/sys` : Interface avec les périphériques et le matériel (sysfs)**

- **Rôle** : Expose les informations et les contrôles liés aux périphériques
matériels et à leurs pilotes via le sous-système `sysfs`.
- **Caractéristiques** :
- Organisé par sous-systèmes matériels (ex. `/sys/block` pour les disques,
`/sys/class` pour les classes de périphériques).
- Permet de modifier dynamiquement certains paramètres (ex. activer/désactiver un
périphérique).
- Exemple : `/sys/class/backlight/` pour ajuster la luminosité d’un écran.
- **Exemple d’utilisation** :
 ```bash
echo 50 > /sys/class/backlight/intel_backlight/brightness
```
Change la luminosité de l’écran (si pris en charge).

- **Nature** : Variable et unsharable (lié au matériel local).

#### 3. **`/dev` : Fichiers de périphériques**

- **Rôle** : Représente les périph obstructions matériels comme des fichiers
spéciaux, permettant aux programmes de communiquer avec eux.
- **Caractéristiques** :
- Contient des fichiers de type "block" (ex. `/dev/sda` pour un disque) ou
"character" (ex. `/dev/tty` pour un terminal).
- Géré dynamiquement par `udev` (le gestionnaire de périphériques du noyau), qui
crée et supprime les fichiers en fonction des périphériques connectés.
- Exemples :
- `/dev/null` : "Poubelle" qui absorbe toute sortie.
- `/dev/random` : Générateur de nombres aléatoires.
- **Exemple d’utilisation** :
```bash
echo "Test" > /dev/null
```
Redirige la sortie vers le vide.

- **Nature** : Variable et unsharable (dépend des périphériques présents).

#### 4. **`/run` : Données d’exécution temporaires**

- **Rôle** : Stocke les données temporaires des processus et services en cours
d’exécution, accessibles uniquement pendant la session actuelle.
- **Caractéristiques** :
- Monté en mémoire (tmpfs), donc volatil (effacé au redémarrage).
- Remplace souvent `/var/run` dans les systèmes modernes.
- Contient des fichiers PID (ex. `/run/[Link]`) ou des sockets (ex.
`/run/dbus/system_bus_socket`).
- **Exemple d’utilisation** :
```bash
cat /run/[Link]
```
Affiche l’ID du processus SSH en cours.

- **Nature** : Variable et unsharable.

#### 5. **`/tmp` (parfois tmpfs) : Fichiers temporaires**

- **Rôle** : Fournit un espace pour les fichiers temporaires créés par les
applications ou les utilisateurs.
- **Caractéristiques** :
- Peut être monté en mémoire (tmpfs) pour plus de rapidité, ou sur disque selon
la configuration.
- Souvent vidé au redémarrage ou selon une politique définie.
- **Exemple d’utilisation** :
```bash
echo "Temp data" > /tmp/testfile
```

- **Nature** : Variable (et parfois sharable dans des cas spécifiques, mais
rarement).

---
### **Pourquoi ces systèmes sont-ils "virtuels" ?**
- **Pas de stockage physique** : Les données ne sont pas écrites sur disque, mais
générées à la volée par le noyau.
- **Montés en mémoire** : Ils utilisent souvent `tmpfs` ou des structures internes
du noyau, ce qui les rend volatils.
- **Interface fichier** : Tout est présenté comme des fichiers, suivant la
philosophie Unix "tout est un fichier".

---

### **Exemple concret d’utilisation combinée**

Pour surveiller un processus intensif :
1. Vérifiez son PID dans `/proc` :
```bash
ls /proc | grep "[0-9]"
```
2. Consultez sa mémoire dans `/proc/[PID]/status`.
3. Vérifiez les périphériques utilisés via `/dev` ou `/sys`.

---

### **Conclusion**
Les systèmes de fichiers virtuels comme `/proc`, `/sys`, `/dev`, `/run`, et parfois
`/tmp` sont des piliers de la flexibilité de Linux. Ils permettent une interaction
transparente avec le noyau, les processus, et le matériel, tout en offrant une
interface simple et standardisée. Leur rôle est de rendre le système vivant et
accessible, sans encombrer le stockage persistant avec des données éphémères. Si
vous voulez explorer un de ces systèmes plus en détail (par exemple, les fichiers
spécifiques dans `/proc`), dites-le-moi !

### **Utilisez les canaux de Linux** ###

1. **`stdin`**(pour standard input) : c'est le canal de l'entrée standard, et par

défaut, lorsque vous lancez une commande, c'est votre clavier. La commande sera
éventuellement capable de lire les informations saisies avec le clavier via ce
canal. Il porte le descripteur de fichier **numéro 0** ;

2. **`stdout`**(pour standard output) : c'est le canal de la sortie standard, et

lorsque vous lancez une commande depuis un terminal, c'est l'écran par défaut. Le
résultat et les données affichées par la commande sont diffusés sur l'écran. Il
porte le descripteur de fichier **numéro 1** ;

3. **`stderr`**(pour standard error) : c'est le canal du flux concernant les

erreurs, et par défaut, lorsque vous lancez une commande, c'est aussi l'écran. La
commande va différencier les données “normales” des données “erreur” et peut
changer de canal pour diffuser ces informations.

Bien sûr ! Les commandes `sed` et `awk` sont des outils puissants sous Unix/Linux
pour manipuler et traiter du texte. Voici un petit aperçu de chacune :

### `sed` (Stream Editor)

`sed` est un éditeur de flux qui permet de modifier du texte en ligne de manière
automatisée, souvent utilisé dans des scripts ou en ligne de commande. Il
fonctionne en lisant un fichier ou une entrée ligne par ligne et en appliquant des
transformations basées sur des expressions régulières.

- **Utilisation courante :**

- Remplacer du texte : `sed 's/vieux/nouveau/' fichier` (remplace la première
occurrence de "vieux" par "nouveau" dans chaque ligne).
- Supprimer des lignes : `sed '/motif/d' fichier` (supprime les lignes contenant
"motif").
- Ajouter ou insérer : `sed '2i texte' fichier` (insère "texte" avant la ligne
2).

- **Exemple :**
```bash
echo "Bonjour le monde" | sed 's/monde/planète/'
```
Résultat : `Bonjour la planète`

- **Point fort :** Idéal pour des modifications simples et rapides, sans avoir à
ouvrir un fichier dans un éditeur.

### `awk` (Aho, Weinberger, Kernighan)

`awk` est un outil plus puissant, conçu pour traiter des données structurées (comme
des fichiers avec des colonnes). Il excelle dans l’extraction et la manipulation de
champs dans du texte.

- **Utilisation courante :**

- Extraire une colonne : `awk '{print $1}' fichier` (affiche la première colonne,
séparée par des espaces par défaut).
- Filtrer des lignes : `awk '$2 > 10 {print $0}' fichier` (affiche les lignes où
la deuxième colonne est supérieure à 10).
- Calculs : `awk '{s += $1} END {print s}' fichier` (somme les valeurs de la
première colonne).

- **Exemple :**
```bash
echo "pomme 5 rouge" | awk '{print $1 " coûte " $2 " euros"}'
```
Résultat : `pomme coûte 5 euros`

- **Point fort :** Parfait pour analyser des fichiers avec des données tabulées
(comme des CSV simples) ou pour des traitements conditionnels.

### Différence clé

- `sed` est orienté vers l’édition de texte (remplacements, suppressions).
- `awk` est plus adapté à l’analyse et à la manipulation de données structurées.

### Combinaison des deux

Ils sont souvent utilisés ensemble dans des pipelines. Par exemple :
```bash
cat fichier | sed 's/,/ /g' | awk '{print $2}'
```
Ici, `sed` remplace les virgules par des espaces, puis `awk` extrait la deuxième
colonne.

Si tu veux un exemple plus spécifique ou une explication sur un cas particulier,

n’hésite pas à demander !

Pas de panique, je vais t’expliquer tout ça étape par étape de manière claire et
simple ! Les **inodes** sont un concept clé dans les systèmes de fichiers
Unix/Linux (comme ext4), et ils peuvent sembler compliqués au début, mais c’est
juste une façon d’organiser les données sur un disque. Allons-y doucement.

---
### Qu’est-ce qu’un inode ?
Un **inode** (index node) est une structure de données qui contient les
**métadonnées** d’un fichier, c’est-à-dire toutes les informations sur le fichier
sauf son contenu brut et son nom. Par exemple :
- Taille du fichier
- Propriétaire (utilisateur et groupe)
- Permissions (lecture, écriture, exécution)
- Dates (dernière modification, dernier accès, etc.)
- **Adresses des blocs de données** où le contenu du fichier est stocké sur le
disque.

Chaque fichier sur ton disque a un inode unique. Imagine l’inode comme une fiche
descriptive qui dit "où trouver les données" et "à quoi ressemble le fichier".

---

### Les blocs de données : où est stocké le contenu ?

Le contenu d’un fichier (par exemple, le texte d’un document ou les pixels d’une
image) est stocké dans des **blocs** sur le disque. Ces blocs sont comme des
petites boîtes de rangement. L’inode doit indiquer où ces boîtes se trouvent, et
c’est là qu’interviennent les **blocs directs** et **indirects**.

#### 1. Les 12 blocs directs

- Dans un inode, il y a **12 champs** qui pointent directement vers des blocs de
données sur le disque. Ces blocs contiennent les données du fichier.
- Exemple : Si ton fichier fait 48 Ko et que chaque bloc peut contenir 4 Ko, les 12
blocs directs peuvent gérer jusqu’à 12 × 4 Ko = 48 Ko. Tout rentre directement dans
ces 12 adresses.

Mais que se passe-t-il si le fichier est plus gros que ça ? On passe aux **blocs
indirects**.

#### 2. Bloc indirect simple (13e champ)

- Le 13e champ de l’inode ne pointe pas directement vers des données, mais vers un
**autre bloc** (un bloc de pointeurs). Ce bloc contient, par exemple, 128 adresses,
et chacune de ces adresses pointe vers un bloc de données.
- Calcul : Si un bloc = 4 Ko et qu’il y a 128 pointeurs, ça fait 128 × 4 Ko = 512
Ko en plus.
- Donc, ce niveau "indirect" permet de gérer des fichiers plus gros.

#### 3. Bloc doublement indirect (14e champ)

- Le 14e champ pointe vers un bloc de pointeurs, qui lui-même contient 128
adresses. Mais cette fois, chaque adresse pointe vers un **nouveau bloc de
pointeurs** (avec 128 adresses chacun), et ces derniers pointent vers des blocs de
données.
- Calcul : 128 × 128 × 4 Ko = 65 536 Ko (soit environ 64 Mo).
- Ça devient énorme ! On appelle ça "doublement indirect" parce qu’il y a deux
niveaux de redirection avant d’arriver aux données.

#### 4. Bloc triplement indirect (15e champ)

- Le 15e champ va encore plus loin : il pointe vers un bloc de pointeurs, qui
pointe vers des blocs de pointeurs, qui pointent vers d’autres blocs de pointeurs,
qui enfin pointent vers les données.
- Calcul : 128 × 128 × 128 × 4 Ko = environ 8 Go.
- C’est le niveau "triplement indirect". Ça permet de gérer des fichiers
gigantesques.

---
### Pourquoi 这么多 (tellement) de redirections ?
Plus un fichier est gros, plus il faut de blocs pour stocker ses données. Les 12
blocs directs suffisent pour les petits fichiers, mais pour les gros, on ajoute ces
niveaux de redirection (indirect, double indirect, triple indirect). C’est une
façon efficace de ne pas gaspiller d’espace dans l’inode tout en supportant des
fichiers de toutes tailles.

**Résumé simple :**

- Petits fichiers → blocs directs (12 max).
- Fichiers moyens → bloc indirect simple.
- Gros fichiers → blocs doublement indirects.
- Fichiers énormes → blocs triplement indirects.

---

### Exemple concret

Imagine un fichier vidéo de 1 Go :
- Les 12 blocs directs gèrent les premiers 48 Ko.
- Le bloc indirect simple gère 512 Ko supplémentaires.
- Le bloc doublement indirect prend en charge 64 Mo.
- Le bloc triplement indirect s’occupe du reste (jusqu’à 8 Go).

L’inode "zoome" sur ces différents niveaux pour trouver toutes les données.

---

### Lien avec les commandes pratiques

Dans ton "screencast" imaginaire, on pourrait voir :
1. **Vérifier un inode** : Avec `ls -i`, tu vois le numéro d’inode d’un fichier.
Avec `stat fichier`, tu vois ses métadonnées.
2. **Copie/déplacement** : Quand tu copies un fichier (`cp`), un nouvel inode est
créé avec de nouvelles adresses de blocs. Un déplacement (`mv`) réutilise souvent
le même inode si c’est sur le même disque.
3. **Suppression** : Supprimer un fichier (`rm`) libère l’inode et ses blocs.
4. **Liens durs** : Un lien dur (`ln fichier lien`) crée une nouvelle entrée qui
pointe vers le même inode (même contenu).
5. **Liens symboliques** : Un lien symbolique (`ln -s fichier lien`) est un fichier
séparé qui pointe vers le chemin du fichier original (nouvel inode).

---

### En résumé
L’inode est comme un GPS pour les données d’un fichier. Il contient des adresses
directes pour les petits fichiers et des "cartes routières" (blocs indirects) pour
les gros fichiers. Plus le fichier grossit, plus les redirections s’empilent, mais
tout reste organisé !

Si quelque chose n’est toujours pas clair, dis-moi où tu bloques, et je zoome

dessus avec toi !

Pas tout à fait ! Tous les blocs dans un système de fichiers Linux **ne contiennent
pas forcément 4 Ko**. La taille des blocs dépend du système de fichiers et de la
manière dont il a été configuré lors de sa création (formatage). Je t’explique ça
clairement.

### La taille des blocs varie selon le système de fichiers

Sous Linux, la taille d’un bloc est définie au moment où tu formates une partition
avec un système de fichiers (comme ext4, XFS, Btrfs, etc.). Les tailles possibles
incluent souvent :
- **1 Ko (1024 octets)**
- **2 Ko (2048 octets)**
- **4 Ko (4096 octets)** ← la plus courante pour ext4
- **8 Ko (8192 octets)** (moins fréquent)

**4 Ko** est une valeur par défaut très répandue, notamment pour le système de
fichiers **ext4**, qui est le standard sur la plupart des distributions Linux
modernes. Mais ce n’est pas une règle absolue pour "tous les blocs de Linux".

### Comment vérifier la taille des blocs ?

Tu peux voir la taille des blocs d’une partition avec la commande `dumpe2fs` (pour
ext2/ext3/ext4) ou `stat` :
- Exemple :
```bash
sudo dumpe2fs /dev/sdX | grep "Block size"
```
(Remplace `/dev/sdX` par ta partition, comme `/dev/sda1`.) Ça te dira la taille
des blocs, par exemple : `Block size: 4096`.

- Avec `stat` sur un fichier :

```bash
stat fichier | grep "IO Block"
```
Ça affiche quelque chose comme : `IO Block: 4096`, indiquant 4 Ko.

### Pourquoi 4 Ko est courant ?

- **Compatibilité** : 4 Ko correspond à la taille des pages mémoire dans la plupart
des architectures modernes (comme x86 ou ARM), ce qui optimise les performances.
- **Équilibre** : C’est assez grand pour limiter la fragmentation des gros
fichiers, mais pas trop pour éviter de gaspiller de l’espace avec les petits
fichiers.

### Exceptions et variations

- **Autres systèmes de fichiers** :
- **XFS** ou **Btrfs** peuvent utiliser des blocs de tailles différentes, parfois
jusqu’à 64 Ko, selon la configuration.
- Les systèmes de fichiers pour des périphériques spécifiques (comme les clés USB
en FAT32) peuvent avoir des tailles de clusters différentes, mais ce n’est plus
vraiment du "Linux natif".
- **Petits blocs** : Si tu formates une partition avec `mkfs.ext4 -b 1024`, tu
auras des blocs de 1 Ko au lieu de 4 Ko.

### Impact sur les inodes

Reprenons l’exemple des 12 blocs directs dans un inode :
- Si la taille des blocs est **1 Ko**, les 12 blocs directs gèrent 12 × 1 Ko = 12
Ko.
- Si c’est **4 Ko**, on a 12 × 4 Ko = 48 Ko (comme dans l’exemple précédent).
- Si c’est **8 Ko**, ça monte à 12 × 8 Ko = 96 Ko.

La capacité totale dépend donc de cette taille de bloc définie au formatage.

### En résumé
- **Non**, tous les blocs sous Linux ne font pas 4 Ko. Ça dépend du système de
fichiers et de son formatage.
- **Oui**, 4 Ko est la taille par défaut la plus courante pour ext4, mais elle peut
être 1 Ko, 2 Ko, 8 Ko, etc., selon les besoins.

Si tu veux vérifier sur ton système ou si tu as un cas précis en tête (comme un

disque dur ou une clé USB), dis-le-moi, et je t’aide à creuser ! Ça te semble plus
clair maintenant ?

Sous Linux, les **liens durs** et les **liens symboliques** (ou liens souples) sont
des mécanismes pour référencer des fichiers, mais ils diffèrent dans leur
fonctionnement et leur usage. Voici une explication claire et concise :

### **1. Lien dur (Hard Link)**

- **Définition** : Un lien dur est une référence directe à un inode (structure de
données contenant les métadonnées d'un fichier, comme son contenu ou son
emplacement sur le disque). Il s'agit d'un autre nom pour le même fichier.
- **Caractéristiques** :
- Crée avec la commande : `ln source lien_dur`.
- Le lien dur et le fichier original partagent le **même inode** et donc le même
contenu. Modifier l'un affecte l'autre.
- Ne peut pas être créé pour un répertoire ou entre différents systèmes de
fichiers (partitions).
- Le fichier original peut être supprimé, mais tant qu’un lien dur existe, les
données restent accessibles.
- Exemple : Si `[Link]` a un lien dur `[Link]`, les deux pointent vers les
mêmes données sur le disque.
- **Utilité** : Sauvegarde ou gestion de fichiers où plusieurs noms doivent pointer
vers les mêmes données.

### **2. Lien symbolique (Soft Link ou Symlink)**

- **Définition** : Un lien symbolique est un fichier spécial qui agit comme un
raccourci ou une référence vers un autre fichier ou répertoire, en stockant son
chemin.
- **Caractéristiques** :
- Crée avec la commande : `ln -s source lien_symbolique`.
- C’est un fichier indépendant avec son propre inode, contenant uniquement le
chemin vers le fichier cible.
- Peut pointer vers des fichiers, des répertoires, ou même des fichiers sur
d’autres systèmes de fichiers.
- Si le fichier cible est supprimé ou déplacé, le lien symbolique devient
**cassé** (pointe vers rien).
- Exemple : Un lien symbolique `[Link]` vers `[Link]` redirige vers
`[Link]`, mais si `[Link]` est supprimé, `[Link]` est inutilisable.
- **Utilité** : Raccourcis pour accéder à des fichiers/répertoires éloignés, ou
pour organiser des systèmes de fichiers.

### **Différences clés**

| **Aspect** | **Lien dur** | **Lien
symbolique** |
|---------------------------|-------------------------------------------|----------
---------------------------------|
| **Nature** | Pointe directement vers l’inode | Pointe
vers le chemin du fichier |
| **Inode** | Partage le même inode | A son
propre inode |
| **Suppression du source** | Données accessibles via autres liens durs | Lien
cassé (inutilisable) |
| **Répertoires** | Non autorisé | Autorisé
|
| **Systèmes de fichiers** | Même système de fichiers uniquement | Peut
traverser systèmes de fichiers |
| **Commande** | `ln source lien` | `ln -s
source lien` |
### **Exemple pratique**
```bash
# Créer un fichier
echo "Contenu" > [Link]

# Créer un lien dur

ln [Link] lien_dur.txt

# Créer un lien symbolique

ln -s [Link] lien_sym.txt

# Vérifier
ls -li
# Résultat : [Link] et lien_dur.txt ont le même inode, lien_sym.txt a un inode
différent
```

### **Conclusion**
- **Liens durs** : Utiles pour des références multiples aux mêmes données, robustes
mais limités.
- **Liens symboliques** : Plus flexibles, idéaux pour des raccourcis, mais
sensibles à la suppression/déplacement du fichier cible.

Si vous avez besoin d’exemples supplémentaires ou d’explications sur une commande

spécifique, faites-le-moi savoir !

# Réseau sous Linux #

### **Configurez le nom du réseau de votre serveur**

1. le fichier`**/proc/sys/kernel/hostname**` qui contient la valeur courante du nom

réseau du serveur,

2. la commande `**hostnamectl**` qui permet de la modifier,

3. le fichier`**/etc/hostname**` qui permet d’initialiser le nom réseau au

démarrage.

### **Configurez les cartes réseaux de manière dynamique**

![[Pasted image [Link]]]

D'accord, vous voulez configurer vos interfaces réseau **manuellement** (adresse IP

statique, par exemple) sur **Ubuntu 24.04**, sans utiliser DHCP, et vous mentionnez
`ip addr` comme méthode de référence. Puisque Ubuntu 24.04 utilise **Netplan** par
défaut pour la gestion des interfaces réseau, vous devez configurer une adresse IP
statique dans un fichier YAML dans `/etc/netplan/`, plutôt que d'utiliser
`/etc/network/interfaces` comme dans les anciennes versions. Cependant, je vais
aussi expliquer comment utiliser `ip addr` temporairement, car vous l'avez
mentionné, et comment rendre la configuration permanente avec Netplan.

### 1. **Configurer manuellement une adresse IP temporaire avec `ip addr`**

La commande `ip addr` permet de configurer une interface réseau, mais cette
configuration est **temporaire** et sera perdue au redémarrage. Voici comment
procéder :

#### Étape 1 : Identifier l'interface réseau

Trouvez le nom de votre interface réseau :
```bash
ip link show
```
Exemple de sortie :
```
1: lo: <LOOPBACK,UP> ...
2: enp0s3: <BROADCAST,MULTICAST,UP> ...
3: wlan0: <BROADCAST,MULTICAST> ...
```
Notez le nom de l’interface (par exemple, `enp0s3` pour Ethernet ou `wlan0` pour
Wi-Fi).

#### Étape 2 : Assigner une adresse IP statique

Pour configurer une adresse IP statique (par exemple, `[Link]/24`) sur
l’interface `enp0s3` :
```bash
sudo ip addr add [Link]/24 dev enp0s3
```
- `[Link]/24` : Adresse IP et masque de sous-réseau ( `/24` =
`[Link]`).
- `dev enp0s3` : Nom de l’interface.

#### Étape 3 : Activer l’interface (si nécessaire)

Assurez-vous que l’interface est activée :
```bash
sudo ip link set enp0s3 up
```

#### Étape 4 : Ajouter une passerelle par défaut

Si vous avez besoin d’accéder à Internet ou à d’autres réseaux, configurez une
passerelle (par exemple, `[Link]`) :
```bash
sudo ip route add default via [Link]
```

#### Étape 5 : Configurer les serveurs DNS

Pour résoudre les noms de domaine, éditez `/etc/[Link]` (temporaire) :
```bash
sudo nano /etc/[Link]
```
Ajoutez, par exemple :
```
nameserver [Link]
nameserver [Link]
```
**Note** : Les modifications dans `/etc/[Link]` peuvent être écrasées par le
système.

#### Étape 6 : Vérifier la configuration

Vérifiez que l’adresse IP est bien assignée :
```bash
ip addr show enp0s3
```
Testez la connectivité :
```bash
ping [Link]
```
**Limitation** : Cette configuration via `ip addr` est temporaire et sera perdue
après un redémarrage. Pour une configuration permanente, utilisez Netplan (voir ci-
dessous).

---

### 2. **Configurer une adresse IP statique de manière permanente avec Netplan**

Pour rendre la configuration manuelle (adresse IP statique) **permanente** sur
Ubuntu 24.04, vous devez modifier un fichier YAML dans `/etc/netplan/`.

#### Étape 1 : Vérifier les fichiers Netplan

Vérifiez les fichiers de configuration existants :
```bash
ls /etc/netplan/
```
Vous devriez voir un fichier comme `[Link]` ou `[Link]`.
S’il n’y en a pas, vous pouvez en créer un.

#### Étape 2 : Éditer le fichier Netplan

Ouvrez ou créez un fichier de configuration, par exemple :
```bash
sudo nano /etc/netplan/[Link]
```

Ajoutez une configuration pour une adresse IP statique. Exemple pour l’interface
`enp0s3` :
```yaml
network:
version: 2
renderer: networkd
ethernets:
enp0s3:
dhcp4: no
addresses:
- [Link]/24
gateway4: [Link]
nameservers:
addresses: [[Link], [Link]]
```

**Explications** :
- `renderer: networkd` : Utilise **systemd-networkd** (recommandé pour les
serveurs). Pour un environnement de bureau, vous pouvez utiliser `renderer:
NetworkManager`.
- `dhcp4: no` : Désactive le DHCP pour cette interface.
- `addresses` : Liste des adresses IP statiques (ici, `[Link]/24`).
- `gateway4` : Passerelle par défaut (par exemple, `[Link]`).
- `nameservers` : Serveurs DNS pour la résolution de noms.

Pour une interface Wi-Fi (`wlan0`), utilisez la section `wifis` :

```yaml
network:
version: 2
renderer: networkd
wifis:
wlan0:
dhcp4: no
addresses:
- [Link]/24
 gateway4: [Link]
nameservers:
addresses: [[Link], [Link]]
access-points:
"MonWiFi":
password: "monmotdepasse"
```

#### Étape 3 : Vérifier la syntaxe

Avant d’appliquer, assurez-vous que le fichier YAML est correct :
```bash
sudo netplan generate
```
Si aucune erreur n’apparaît, la syntaxe est valide.

#### Étape 4 : Appliquer la configuration

Appliquez les changements :
```bash
sudo netplan apply
```

#### Étape 5 : Vérifier la configuration

Confirmez que l’adresse IP est appliquée :
```bash
ip addr show enp0s3
```
Testez la connectivité :
```bash
ping [Link]
```

---

### 3. **Exemple complet pour plusieurs interfaces**

Si vous avez plusieurs interfaces (par exemple, Ethernet `enp0s3` et Wi-Fi
`wlan0`), votre fichier `/etc/netplan/[Link]` pourrait ressembler à ceci :
```yaml
network:
version: 2
renderer: networkd
ethernets:
enp0s3:
dhcp4: no
addresses:
- [Link]/24
gateway4: [Link]
nameservers:
addresses: [[Link], [Link]]
wifis:
wlan0:
dhcp4: no
addresses:
- [Link]/24
gateway4: [Link]
nameservers:
addresses: [[Link], [Link]]
access-points:
"MonWiFi":
password: "monmotdepasse"
```

---

### 4. **Pourquoi préférer Netplan à `ip addr` pour une configuration permanente ?
**
- **`ip addr`** : Rapide pour des tests ou des configurations temporaires, mais non
persistant après redémarrage.
- **Netplan** : Stocke la configuration de manière permanente, est compatible avec
Ubuntu 24.04, et prend en charge des configurations complexes (Ethernet, Wi-Fi,
VLAN, etc.).

---

### 5. **Dépannage**
- **Erreur de syntaxe YAML** : Vérifiez l’indentation (2 espaces, pas de
tabulations). Utilisez `sudo netplan generate` pour détecter les erreurs.
- **Interface non configurée** : Confirmez le nom de l’interface avec `ip link
show`.
- **Pas de connectivité** :
- Vérifiez la passerelle avec `ip route`.
- Testez les DNS avec `ping [Link]`.
- Assurez-vous que l’interface est active : `sudo ip link set enp0s3 up`.

---

![[Pasted image [Link]]]

Pour les sytèmes RedHat

![[Pasted image [Link]]]

Quand vous ajoutez une passerelle par défaut avec ip route add default via IP, le
système a besoin de savoir par quelle interface réseau envoyer les paquets à cette
passerelle. Voici pourquoi :

Plusieurs interfaces possibles: Un système peut avoir plusieurs interfaces réseau

(par exemple, enp0s3 pour Ethernet, wlan0 pour Wi-Fi). Sans préciser l'interface,
le système ne sait pas par où envoyer les paquets.
Association réseau/interface: La passerelle (par exemple, [Link]) doit être
accessible via une interface spécifique connectée au réseau local correspondant.
Par exemple, si enp0s3 est connecté au réseau [Link]/24, la passerelle
[Link] est joignable via enp0s3, pas via une autre interface comme wlan0.
Éviter les erreurs : Si vous ne spécifiez pas l'interface, la commande peut échouer
avec une erreur comme Nexthop has invalid gateway ou produire un comportement
imprévisible, car le système ne peut pas déterminer le chemin correct.

### **Configurez les résolutions de noms**

Pour configurer la résolution de noms sous Linux, il faut principalement modifier

les fichiers liés au système de résolution DNS. Voici les étapes détaillées :

### 1. **Configurer le fichier `/etc/[Link]`**

Ce fichier spécifie les serveurs DNS utilisés pour la résolution de noms.
- **Éditez le fichier** :
```bash
sudo nano /etc/[Link]
```

- **Ajoutez des serveurs DNS** :

Ajoutez des lignes avec les adresses des serveurs DNS, par exemple :
```
nameserver [Link] # Serveur DNS de Google
nameserver [Link] # Serveur DNS secondaire de Google
nameserver [Link] # Serveur DNS de Cloudflare (optionnel)
```

- **Sauvegardez et quittez** :
Appuyez sur `Ctrl+O`, `Entrée`, puis `Ctrl+X` dans nano.

**Note** : Sur certaines distributions modernes (comme celles utilisant `systemd-

resolved`), `/etc/[Link]` peut être un lien symbolique géré automatiquement.
Dans ce cas, modifiez la configuration via `systemd-resolved` (voir étape 4).

---

### 2. **Configurer le fichier `/etc/hosts`**

Le fichier `/etc/hosts` permet de définir des correspondances statiques entre noms
d'hôtes et adresses IP, résolues localement avant de consulter le DNS.

- **Éditez le fichier** :
```bash
sudo nano /etc/hosts
```

- **Ajoutez des entrées** :

Par exemple :
```
[Link] localhost
[Link] [Link]
```

- **Sauvegardez et quittez**.

---

### 3. **Configurer l'ordre de résolution dans `/etc/[Link]`**

Le fichier `/etc/[Link]` définit l'ordre dans lequel le système recherche
les informations de résolution de noms.

- **Éditez le fichier** :
```bash
sudo nano /etc/[Link]
```

- **Modifiez la ligne `hosts`** :

Par exemple, pour vérifier d'abord `/etc/hosts`, puis les serveurs DNS :
```
hosts: files dns
```
- `files` : Utilise `/etc/hosts`.
- `dns` : Utilise les serveurs DNS de `/etc/[Link]`.
- **Sauvegardez et quittez**.

---

### 4. **Utiliser `systemd-resolved` (si applicable)**

Sur les systèmes utilisant `systemd-resolved` (comme Ubuntu 18.04+ ou Fedora), la
résolution DNS est gérée par ce service.

- **Vérifiez si `systemd-resolved` est actif** :

```bash
systemctl status systemd-resolved
```

- **Configurez les serveurs DNS** :

Modifiez `/etc/systemd/[Link]` :
```bash
sudo nano /etc/systemd/[Link]
```
Ajoutez ou modifiez la section `[Resolve]` :
```
[Resolve]
DNS=[Link] [Link]
FallbackDNS=[Link]
```

- **Redémarrez le service** :
```bash
sudo systemctl restart systemd-resolved
```

- **Vérifiez la configuration** :
```bash
resolvectl status
```

---

### 5. **Tester la résolution de noms**

- Testez avec `nslookup` ou `dig` :
```bash
nslookup [Link]
```
ou
```bash
dig [Link]
```

- Testez avec `ping` :

```bash
ping [Link]
```

---

### 6. **Protéger `/etc/[Link]` contre les modifications automatiques**

Si `/etc/[Link]` est écrasé par un gestionnaire de réseau (comme
NetworkManager), vous pouvez :
- **Rendre le fichier immuable** :
```bash
sudo chattr +i /etc/[Link]
```
Pour le modifier à nouveau, utilisez :
```bash
sudo chattr -i /etc/[Link]
```

- **Configurer via NetworkManager** (si utilisé) :

Éditez la configuration réseau :
```bash
sudo nano /etc/NetworkManager/[Link]
```
Ajoutez sous la section `[main]` :
```
dns=none
```
Puis redémarrez NetworkManager :
```bash
sudo systemctl restart NetworkManager
```

---

### 7. **Dépannage courant**

- **Problèmes de résolution** :
- Vérifiez que les serveurs DNS sont accessibles : `ping [Link]`.
- Assurez-vous que le service réseau fonctionne : `systemctl status networking`
ou `systemctl status NetworkManager`.
- Vérifiez les permissions des fichiers (`/etc/[Link]`, `/etc/hosts`).

- **Journaux** :
Consultez les journaux pour les erreurs liées à `systemd-resolved` :
```bash
journalctl -u systemd-resolved
```

---

### Résumé
- Modifiez `/etc/[Link]` pour les serveurs DNS.
- Configurez `/etc/hosts` pour les résolutions statiques.
- Ajustez `/etc/[Link]` pour l'ordre de résolution.
- Utilisez `systemd-resolved` si votre système le prend en charge.
- Testez et sécurisez la configuration.

Si vous avez une configuration réseau spécifique (par exemple, DHCP, VPN),
précisez-la pour des instructions plus adaptées !

# Connectez-vous à distance avec SSH

Le protocole SSH se définit par l'utilisation des deux procédés de cryptographie :

1. asymétrique pour mettre en place un échange sécurisé avec le client,

2. et symétrique pour gérer les données.

Le principe de fonctionnement est le suivant :

1. Le serveur écoute les demandes de connexions entrantes ;

2. Un client demande une connexion, le serveur lui répond les algorithmes de

chiffrement à sa disposition ;

3. Le client valide un algorithme et le serveur fournit au client sa clé publique ;

4. À partir de ce moment-là, le client peut vérifier que tous les messages qu'il va
recevoir proviennent bien du serveur ;

5. Le client et le serveur échangent grâce à la cryptographie asymétrique pour

s'accorder sur une clé de chiffrement symétrique basée sur un très grand nombre
premier, on l'appelle la **clé de session SSH** ;

6. Une fois cette clé partagée, le client et le serveur peuvent l'utiliser pour
tout le reste de la session.- **`sshd`**: le service SSH ;

- **`ssh`**: le client SSH ;

- **`ssh-keygen`** et **`ssh-copy-id`**: les utilitaires de gestion de clé RSA, DSA

;

- **`scp`** et **`sftp`**: les clients permettant le transfert de données via SSH.

ssh@IP/Résolution des noms

---

### 📦💬 **Scénario : Envoi secret d’un gros paquet + clé pour l’ouvrir**

Imaginons que tu veux envoyer un **coffre rempli de documents secrets** à ton ami
(des données ), mais tu veux le faire **de façon super sécurisée**.

---

### Étape 1 – Créer une clé spéciale (symétrique)

Tu fabriques un **cadenas** (chiffrement symétrique) avec une **clé spéciale** qui

ouvre ce coffre.
Ce cadenas est **super rapide à ouvrir/fermer**, donc parfait pour sécuriser
**beaucoup de documents** rapidement.

---

### 📬 Étape 2 – Sécuriser la clé avec un autre cadenas (asymétrique)

Mais… tu dois **envoyer la clé du cadenas** à ton ami, sans que personne ne puisse
l'intercepter.

Heureusement, ton ami t’a donné **un cadenas magique** (sa **clé publique**
asymétrique), que **seul lui peut ouvrir** avec sa **clé privée**.
Alors tu :

1. **Chiffres la clé du coffre** avec **le cadenas magique de ton ami** (clé
publique asymétrique),

2. Et tu lui envoies **le coffre scellé + la clé chiffrée**.

---

### 🔓 Étape 3 – Déchiffrage chez ton ami

Ton ami :

- Utilise **sa clé privée** pour **ouvrir** le cadenas magique et récupérer **la
clé du coffre**,

- Puis utilise cette **clé symétrique** pour **ouvrir le coffre** et lire les
documents.

---

### 🧠 Résumé de l’analogie :

|Élément|Représente quoi ?|
|---|---|
|Coffre + documents|Les données (message à envoyer)|
|Cadenas du coffre|Chiffrement symétrique (rapide)|
|Clé du coffre|Clé symétrique|
|Cadenas magique|Clé publique (chiffrement asymétrique)|
|Clé pour le cadenas magique|Clé privée (déchiffrement asymétrique)|

---

🧪 Cette technique est utilisée par **HTTPS** (le cadenas de ton navigateur), les
**VPN**, ou encore **OpenSSL**.
Elle permet de **profiter de la vitesse du chiffrement symétrique** tout en
**gardant la sécurité de l’asymétrique** pour l’échange des clés.

Tu veux que je te raconte comment ça se passe exactement quand tu ouvres un site en

HTTPS ? C’est le même délire 😄

Très bonne question Mario 😎 !

Se connecter en SSH **sans mot de passe**, c’est possible grâce au **chiffrement
asymétrique** avec une **paire de clés SSH**.

Voici comment ça marche **étape par étape**, puis je te montre **comment le faire
concrètement** sur Ubuntu :

---

## 🧠 **Le principe (simple) :**

Tu vas :

1. **Créer une paire de clés SSH** (publique + privée).

2. **Copier ta clé publique sur le serveur distant.**

3. Ensuite, quand tu te connectes, **ton ordi prouve son identité avec la clé
privée**, et le serveur t’autorise sans te demander de mot de passe.

---

## ⚙️ **Étapes concrètes sur Ubuntu :**

### ✅ 1. Génère la paire de clés (si ce n’est pas déjà fait) :

Dans ton terminal :

```bash
ssh-keygen
```

- Appuie sur **Entrée** plusieurs fois (le chemin par défaut est `~/.ssh/id_rsa`).

- Tu peux laisser le champ de **passphrase vide** si tu veux te connecter sans mot

de passe **du tout**.

---

### ✅ 2. Envoie ta **clé publique** sur le serveur :

```bash
ssh-copy-id utilisateur@adresse_du_serveur
```

> Exemple :

```bash
ssh-copy-id mario@[Link]
```

Tu tapes ton **mot de passe UNE seule fois** ici. Ensuite c’est bon à vie (ou
jusqu'à ce que la clé change).

---

### ✅ 3. Teste ta connexion SSH :

```bash
ssh utilisateur@adresse_du_serveur
```

> Tu ne devrais **plus avoir besoin de taper le mot de passe** 🥳

---

## 📝 Quelques remarques :

- La clé publique est copiée dans : `~/.ssh/authorized_keys` du serveur distant.

- Ta **clé privée** reste **sur ta machine locale** et **ne doit jamais être
partagée**.
- Pour plus de sécurité, tu peux toujours protéger ta clé privée avec une
passphrase (comme un mot de passe local).

---

Tu veux que je t’aide à automatiser ça ou à le faire pour plusieurs serveurs d’un

coup ?

#!/bin/bash
# Script pour configurer une connexion SSH sans mot de passe

# Variables (à adapter)
USER="user"
SERVER="adresse_du_serveur"
KEY_FILE="$HOME/.ssh/id_rsa"

# Étape 1 : Générer une paire de clés SSH (si elle n'existe pas)
if [ ! -f "$KEY_FILE" ]; then
echo "Génération de la paire de clés SSH..."
ssh-keygen -t rsa -b 4096 -f "$KEY_FILE" -N ""
else
echo "Clé SSH existante trouvée : $KEY_FILE"
fi

# Étape 2 : Copier la clé publique sur le serveur

echo "Copie de la clé publique sur $USER@$SERVER..."
ssh-copy-id -i "$KEY_FILE.pub" "$USER@$SERVER"

# Étape 3 : Tester la connexion

echo "Test de la connexion SSH sans mot de passe..."
ssh "$USER@$SERVER" "echo 'Connexion réussie !'"

echo "Configuration terminée !"

# Transférez des fichiers par le réseau

### **Téléchargez sur internet avec `wget` et `curl`**

**`wget`** est [un projet GNU]([Link] Ce petit

logiciel permet de télécharger des fichiers en utilisant les protocoles Internet
communs, comme HTTP, ou FTP.

Il est possible de l'installer depuis les sources, ou alors d'utiliser le package

mis à disposition par les distributions. Son utilisation est assez simple et
intuitive, pour télécharger un fichier, en passant l'URL complète du fichier en
paramètre

`**curl**` s'appuie sur [les librairies partagées libcurl, et diffusé sous licence
MIT]([Link]

Dans le périmètre des fonctionnalités de base, il est comparable à **`wget`**, à

une différence non négligeable : il ne propose pas de téléchargement récursif.
C'est la raison principale pour laquelle je choisis directement le premier plutôt
que le second.
Par contre, de son côté, **`curl`** se distingue surtout pour la liste des
protocoles compatibles (DICT, FILE, FTP, FTPS, Gopher, HTTP, HTTPS, IMAP, IMAPS,
LDAP, LDAPS, POP3, POP3S, RTMP, RTSP, SCP, SFTP, SMB, SMBS, SMTP, SMTPS, telnet and
TFTP).

Pour plus d'informations, vous pouvez vous rendre sur [le site de référence]
([Link]

### **Transférez des fichiers par SSH**

![[Pasted image [Link]]]

### **Transférez des fichiers par FTP/FTPS/SFTP**

# Analysez les principaux fichiers de traces

### **Consultez les répertoires des fichiers de traces de `rsyslog`**

Pour analyser les principaux fichiers de traces sous Linux et configurer leur
centralisation sur un serveur distant, nous allons examiner les fichiers de logs
courants, les outils utilisés (principalement **rsyslog**), et les modifications
nécessaires sur le serveur et les clients. Voici une réponse structurée et concise.

---

### **1. Principaux fichiers de traces sous Linux**

Les fichiers de logs sous Linux sont généralement stockés dans le répertoire
`/var/log`. Voici les plus courants et leur rôle :

- **/var/log/syslog** ou **/var/log/messages** : Contient les messages système

globaux, y compris ceux du démarrage, des services, et du noyau (selon la
distribution, comme Debian pour `syslog` ou CentOS pour `messages`).
- **/var/log/[Link]** : Enregistre les événements d’authentification, comme les
connexions SSH, les échecs de connexion, et les changements de privilèges.
- **/var/log/[Link]** : Stocke les messages du noyau, utiles pour diagnostiquer
des problèmes matériels ou de pilotes.
- **/var/log/dmesg** : Contient les messages du noyau au démarrage, souvent
utilisés pour analyser les problèmes de boot.
- **/var/log/[Link]** : Enregistre les activités des serveurs de messagerie
(ex. : Postfix, Sendmail).
- **/var/log/apache2/** ou **/var/log/nginx/** : Logs spécifiques aux serveurs web
(accès, erreurs).
- **/var/log/[Link]** : Trace les tâches planifiées exécutées par `cron`.
- **/var/log/secure** (sur certaines distributions comme Red Hat) : Similaire à
`[Link]`, pour les événements de sécurité.

Ces fichiers sont générés par les services et le système, souvent via le protocole
**syslog**, et peuvent être centralisés pour une gestion simplifiée et une
meilleure sécurité.

---

### **2. Centralisation des logs avec Rsyslog**

**Rsyslog** est l’outil standard pour la gestion et la centralisation des logs sous
Linux. Il remplace l’ancien **syslogd** et utilise le protocole **Syslog**
(UDP/TCP, port 514 par défaut) ou **RELP** pour un transfert fiable. Voici les
étapes pour configurer la centralisation des logs sur un serveur distant.

#### **2.1. Modifications sur le serveur (serveur de logs)**

Le serveur de logs reçoit et stocke les logs des clients. Voici les étapes pour le
configurer :

1. **Installer Rsyslog** (si ce n’est pas déjà fait) :

```bash
sudo apt update && sudo apt install rsyslog # Debian/Ubuntu
sudo yum install rsyslog # CentOS/RHEL
```

2. **Configurer Rsyslog pour recevoir les logs** :

- Éditez le fichier de configuration principal : `/etc/[Link]` ou un
fichier dans `/etc/rsyslog.d/`.
- Activez les modules pour recevoir les logs via le réseau (TCP recommandé pour
la fiabilité) :
```bash
# Décommentez ou ajoutez ces lignes dans /etc/[Link]
module(load="imudp") # Pour UDP (optionnel, moins fiable)
input(type="imudp" port="514")
module(load="imtcp") # Pour TCP (recommandé)
input(type="imtcp" port="514")
```

3. **Organiser les logs des clients** :

- Pour séparer les logs par client, définissez un template dans
`/etc/[Link]` :
```bash
template(name="RemoteLogs" type="string" string="/var/log/remote/%HOSTNAME
%.log")
*.* ?RemoteLogs
```
Cela crée un fichier de log distinct pour chaque client dans
`/var/log/remote/`, nommé selon son hostname.

4. **Ouvrir le port réseau** :

- Assurez-vous que le port 514 (UDP ou TCP) est ouvert dans le pare-feu :
```bash
sudo ufw allow 514/tcp # Debian/Ubuntu
sudo firewall-cmd --add-port=514/tcp --permanent && sudo firewall-cmd --reload
# CentOS/RHEL
```

5. **Redémarrer Rsyslog** :
```bash
sudo systemctl restart rsyslog
```

6. **Vérifier la réception des logs** :

- Utilisez la commande `tail -f /var/log/remote/*` pour voir les logs entrants.

#### **2.2. Modifications sur le client**

Les clients envoient leurs logs au serveur central. Voici les étapes :
1. **Installer Rsyslog** :
- Assurez-vous que `rsyslog` est installé (comme pour le serveur).

2. **Configurer l’envoi des logs** :

- Éditez `/etc/[Link]` ou ajoutez un fichier dans `/etc/rsyslog.d/` (ex. :
`/etc/rsyslog.d/[Link]`).
- Ajoutez une ligne pour rediriger les logs vers le serveur :
```bash
*.* @<IP_serveur>:514 # Pour UDP
*.* @@<IP_serveur>:514 # Pour TCP (recommandé)
```
Remplacez `<IP_serveur>` par l’adresse IP ou le nom du serveur de logs.

3. **(Optionnel) Filtrer les logs à envoyer** :

- Pour envoyer uniquement certains logs (ex. : authentification), spécifiez une
facilité :
```bash
auth,authpriv.* @@<IP_serveur>:514
```

4. **Redémarrer Rsyslog** :
```bash
sudo systemctl restart rsyslog
```

5. **Tester l’envoi** :
- Générez un log de test sur le client :
```bash
logger "Test message from client"
```
- Vérifiez sur le serveur si le message apparaît dans le fichier de log
correspondant.

#### **2.3. Sécurisation de la transmission**

- **Utiliser TCP** : TCP garantit la réception des logs, contrairement à UDP.

- **Chiffrement** : Configurez TLS pour sécuriser les transferts :
- Installez le paquet `rsyslog-gnutls` sur le serveur et les clients.
- Configurez les certificats et activez le module `imtcp` avec TLS dans
`/etc/[Link]`.
- **Cloisonnement** : Isolez le serveur de logs sur un réseau sécurisé pour éviter
qu’il ne devienne une cible.

---

### **3. Outils complémentaires pour l’analyse**

Une fois les logs centralisés, utilisez des outils pour les analyser et les
visualiser :

- **LogAnalyzer** : Interface web pour visualiser et trier les logs collectés par
Rsyslog.[]([Link]
- **Graylog** : Solution open-source pour collecter, analyser, et visualiser les
logs en temps réel.[]([Link]
pour-la-securite/)
- **ELK Stack** (Elasticsearch, Logstash, Kibana) : Puissant pour l’indexation, la
recherche, et la création de tableaux de
bord.[]([Link]
securite/)
- **Wazuh** : XDR open-source pour associer les logs à des menaces (ex. : MITRE
ATT&CK).[]([Link]
securite/)

---

### **4. Avantages de la centralisation**

- **Sécurité** : Les logs centralisés sont protégés contre la suppression par un

attaquant sur une machine compromise.[]([Link]
centralisation-des-logs-sous-linux)
- **Diagnostic** : Facilite l’analyse des pannes, même en cas de crash d’un
serveur.[]([Link]
securite/)
- **Audit** : Simplifie la conformité réglementaire (ex. : RGPD, ISO 27001).[]
([Link]
- **Efficacité** : Une interface unique pour surveiller plusieurs systèmes.[]
([Link]

---

### **5. Bonnes pratiques**

- **Rotation des logs** : Configurez `logrotate` pour compresser et archiver les

logs afin d’éviter la saturation du disque
(`/etc/[Link]`).[]([Link]
linux/)
- **Synchronisation du temps** : Utilisez NTP pour des horodatages cohérents sur
tous les systèmes.[]([Link]
votre-supervision-sur-des-logs-de-qualite-avec-rsyslog)
- **Surveillance** : Implémentez des alertes (ex. : avec Graylog ou Wazuh) pour
détecter les anomalies en temps réel.[]([Link]
- **Stockage** : Envisagez un **Data Lake** pour stocker les logs bruts à long
terme.[]([Link]

---

### **Conclusion**

La centralisation des logs sous Linux avec **Rsyslog** est une pratique essentielle
pour la sécurité et la gestion des systèmes. Les principaux fichiers de traces
(`syslog`, `[Link]`, `[Link]`, etc.) sont collectés localement dans `/var/log`
et peuvent être envoyés à un serveur distant en configurant Rsyslog sur le serveur
(activation des modules `imtcp`/`imudp`, templates) et les clients (redirection via
`@` ou `@@`). Des outils comme Graylog ou ELK améliorent l’analyse et la
visualisation. Assurez-vous de sécuriser la transmission (TCP/TLS) et de suivre les
bonnes pratiques pour une gestion efficace.

### **Analysez les traces d’authentification

### **Analysez l’initialisation des cartes réseau depuis les fichiers de traces**

soit [Link] soit /var/syslog

### **Relevez les redémarrages du système**

En consultant [la norme Filesystem Hierarchy
Standard]([Link] vous pourrez constater
qu’elle définit un fichier de traces un peu particulier : **/var/log/wtmp**. Ce
fichier contient l'ensemble des connexions et déconnexions de tous les
utilisateurs.

Pour des raisons de sécurité, ce fichier est maintenu au format **binaire** par le
noyau, car c'est beaucoup plus difficile d'effacer ses traces dans un fichier
binaire !

Mais il permet également de relever tous les redémarrages du système via un pseudo-
compte nommé **`reboot`**.

### **Auditez qui fait quoi en direct sur le système**

Enfin, dernières commandes très utiles :**`w`**(comme "work") et **`who`**. Ces

commandes permettent de relever qui sont les utilisateurs connectés à l’instant T
et quelles sont leurs activités.

La commande **`who`** permet de visualiser qui sont les comptes connectés à

l’instant T, elle dispose de certaines options intéressantes permettant de relever
par exemple la date du dernier redémarrage.

La commande **`w`** effectue en fait un condensé de plusieurs autres commandes

permettant de relever notamment l'activité du processeur.

# Analysez l’activité du processeur et des processus

Voici un résumé des principales commandes Linux pour la gestion des processus, avec
une brève description de leur utilité :

### 1. **Afficher les processus**

- **`ps`** : Affiche les processus en cours pour l'utilisateur actuel dans le
terminal.
- Exemple : `ps aux` (liste tous les processus avec détails).
- Options utiles : `aux` (tous les processus), `ef` (format hiérarchique).

- **`top`** : Affiche en temps réel les processus actifs, leur utilisation

CPU/mémoire.
- Alternative : `htop` (plus visuel et interactif, nécessite installation).

- **`pgrep`** : Recherche des processus par nom ou autre critère.

- Exemple : `pgrep -u user` (liste les processus de l'utilisateur spécifié).

### 2. **Gérer les processus**

- **`kill`** : Envoie un signal pour terminer un processus (par PID).
- Exemple : `kill -9 1234` (termine le processus avec PID 1234 de force avec
SIGKILL).
- Signaux courants : `-1` (SIGHUP, recharger), `-15` (SIGTERM, arrêt propre), `-
9` (SIGKILL, arrêt forcé).

- **`killall`** : Termine les processus par leur nom.

- Exemple : `killall firefox` (termine toutes les instances de Firefox).

- **`pkill`** : Termine les processus en fonction d’un critère (nom, utilisateur,

etc.).
- Exemple : `pkill -u user` (termine tous les processus de l'utilisateur).
### 3. **Priorité des processus**
- **`nice`** : Définit la priorité d’un nouveau processus (valeur de -20 à 19, plus
bas = plus prioritaire).
- Exemple : `nice -n 10 commande` (lance la commande avec priorité 10).

- **`renice`** : Modifie la priorité d’un processus existant.

- Exemple : `renice 5 -p 1234` (change la priorité du processus avec PID 1234 à
5).

### 4. **Exécution en arrière-plan**

- **`&`** : Lance une commande en arrière-plan.
- Exemple : `firefox &` (lance Firefox en arrière-plan).

- **`bg`** : Passe un processus suspendu en arrière-plan.

- Exemple : `bg %1` (relance le job 1 en arrière-plan).

- **`fg`** : Ramène un processus en avant-plan.

- Exemple : `fg %1` (ramène le job 1 au premier plan).

- **`jobs`** : Liste les processus en arrière-plan dans la session courante.

### 5. **Surveiller et limiter**

- **`watch`** : Exécute une commande périodiquement pour surveiller son état.
- Exemple : `watch -n 2 ps aux` (actualise `ps aux` toutes les 2 secondes).

- **`nohup`** : Permet à un processus de continuer après la déconnexion du

terminal.
- Exemple : `nohup commande &` (lance la commande en arrière-plan, persistante).

- **`ulimit`** : Contrôle les limites des ressources pour les processus.

- Exemple : `ulimit -u 100` (limite à 100 processus par utilisateur).

### 6. **Informations avancées**

- **`lsof`** : Liste les fichiers ouverts par un processus.
- Exemple : `lsof -p 1234` (fichiers ouverts par le PID 1234).

- **`strace`** : Trace les appels système d’un processus.

- Exemple : `strace -p 1234` (surveille les appels système du PID 1234).

- **`pmap`** : Affiche la carte mémoire d’un processus.

- Exemple : `pmap 1234` (montre l’utilisation mémoire du PID 1234).

### 7. **Gestion des jobs**

- **`ctrl+z`** : Suspend un processus en cours (le met en pause).
- **`ctrl+c`** : Termine un processus en cours.
- **`jobs`** : Liste les jobs suspendus ou en arrière-plan.
- **`disown`** : Détache un processus du terminal actuel.
- Exemple : `disown %1` (détache le job 1).

### Remarques :
- Les commandes comme `kill`, `killall`, et `pkill` nécessitent prudence, surtout
avec `-9` (SIGKILL), car elles peuvent causer des pertes de données.
- Utilisez `man commande` (ex. `man ps`) pour plus de détails sur chaque commande.
- Certaines commandes (ex. `htop`, `strace`) peuvent nécessiter une installation
préalable.

### **Déclenchez manuellement la terminaison d’un processus**

Il n'est pas nécessaire de connaître tous ces signaux, seuls ceux permettant
d'interrompre le fonctionnement d'un processus nous intéressent ici. Ils sont au
nombre de 3 :

1. SIGINT (signal numéro 2)

2. SIGTERM (signal numéro 15)

3. SIGKILL (signal numéro 9)

#### SIGINT et SIGTERM

Ces deux signaux indiquent au processus sa terminaison de façon propre. Autrement

dit : il y a ici une volonté à ce que ce soit le processus lui-même qui se termine,
en libérant correctement toutes les ressources qu'il occupe à cet instant.

SIGINT est assez connu, puisque généralement il correspond à l'interruption clavier

**CTRL+c**.

Notez que ces deux signaux peuvent être ignorés par le processus cible (je pense
notamment au processus parent de tous les autres, **`init`** ou **`systemd`** ou
encore à tous les processus gérés directement par le noyau Linux) .

#### SIGKILL

C’est le signal destructeur par définition. Souvent, il est envoyé lorsque les deux
précédents n'ont pas fonctionné. Le processus ciblé est terminé brutalement :

- pas forcément aussi proprement qu'avec SIGINT ou SIGTERM,

- et les ressources associées ne sont pas libérées proprement.

Les processus ne peuvent pas ignorer ce signal. Tout simplement parce qu'il ne leur
est pas adressé directement. SIGKILL est envoyé au processus principal de Linux
(**`init`** ou **`systemd`**) qui se charge, lui, de tuer le processus cible.