[LINUX]# Fichier: python_cheats/cheatsheets/linux.txt
# Cheatsheet Linux - Guide Complet & Exhaustif


## **Sections principales :**

[OK] 1. **Navigation & Système de fichiers** - ls, cd, mkdir, cp, mv, rm, liens, etc.
[OK] 2. **Affichage & Manipulation** - cat, grep, sed, awk, compression, etc.
[OK] 3. **Permissions & Propriété** - chmod, chown, ACL, attributs
[OK] 4. **Recherche** - find, locate, whereis, which
[OK] 5. **Processus & Système** - ps, top, kill, nice, monitoring
[OK] 6. **Réseau** - ip, ssh, scp, firewall, DNS, tcpdump, etc.
[OK] 7. **Disques & Filesystems** - df, du, mount, LVM, RAID
[OK] 8. **Utilisateurs & Groupes** - useradd, usermod, sudo, groupes
[OK] 9. **Services & Systemd** - systemctl, journalctl
[OK] 10. **Gestion Paquets** - apt, yum, dnf, pacman, snap, etc.
[OK] 11. **Shell & Variables** - bash, alias, historique, scripts
[OK] 12. **Cron & Tâches** - crontab, at, systemd timers
[OK] 13. **Logs & Debugging** - journalctl, dmesg, strace, ltrace
[OK] 14. **Archivage & Backup** - tar, rsync, dd, borgbackup
[OK] 15. **Sécurité** - firewall, fail2ban, SELinux, AppArmor, GPG
[OK] 16. **Performance** - tuning, benchmarking, profiling
[OK] 17. **Conteneurs** - Docker, Podman, LXC, KVM
[OK] 18. **Screen & Tmux** - multiplexeurs terminaux
[OK] 19. **Bases de données** - MySQL, PostgreSQL, MongoDB, Redis
[OK] 20. **Web servers** - Nginx, Apache
[OK] 21. **SSL/TLS** - OpenSSL, Let's Encrypt
[OK] 22. **Astuces avancées** - one-liners, parallel processing, etc.


[OK] NAVIGATION & SYSTÈME DE FICHIERS

# === DÉPLACEMENT ===

# Afficher répertoire courant
pwd
pwd -P                          # Chemin physique (résout symlinks)
pwd -L                          # Chemin logique (avec symlinks)

# Changer de répertoire
cd /chemin/absolu
cd chemin/relatif
cd ..                           # Répertoire parent
cd ../..                        # Deux niveaux au-dessus
cd -                            # Répertoire précédent
cd ~                            # Répertoire home
cd                              # Répertoire home (équivalent)
cd ~/Documents
cd ~username                    # Home d'un autre utilisateur

# Répertoires spéciaux
.                               # Répertoire courant
..                              # Répertoire parent
~                               # Home de l'utilisateur courant
~username                       # Home d'un utilisateur spécifique
/                               # Racine du système
-                               # Répertoire précédent (avec cd)

# === LISTER FICHIERS & RÉPERTOIRES ===

# Liste basique
ls
ls -l                           # Format long (détails)
ls -la                          # Tout inclure (fichiers cachés)
ls -lh                          # Tailles lisibles (human-readable)
ls -lS                          # Trier par taille
ls -lt                          # Trier par date de modification
ls -ltr                         # Trier par date (inverse)
ls -lR                          # Récursif
ls -ld */                       # Seulement répertoires
ls -1                           # Un fichier par ligne

# Options avancées
ls -la --color=auto             # Avec couleurs
ls -li                          # Avec numéros d'inodes
ls -lh --block-size=M           # Tailles en MB
ls -X                           # Trier par extension
ls --group-directories-first    # Répertoires en premier
ls -F                           # Ajoute indicateurs (/ pour dirs, * pour executables)
ls -Q                           # Noms entre guillemets
ls --time=atime                 # Trier par dernier accès
ls --time=ctime                 # Trier par changement metadata

# Filtres et patterns
ls *.txt                        # Tous les .txt
ls file?.txt                    # file1.txt, fileA.txt, etc.
ls file[1-3].txt                # file1.txt, file2.txt, file3.txt
ls [abc]*                       # Commence par a, b ou c
ls *[!0-9]                      # Ne finit pas par un chiffre

# Alternatives modernes
exa -la                         # Alternative moderne à ls (nécessite installation)
lsd -la                         # LSD (LSDeluxe) - ls moderne
tree                            # Vue arborescente
tree -L 2                       # Limiter profondeur à 2 niveaux
tree -d                         # Seulement répertoires
tree -I 'node_modules|.git'     # Exclure patterns

# === CRÉER FICHIERS & RÉPERTOIRES ===

# Créer fichiers
touch file.txt                  # Crée fichier vide ou met à jour timestamp
touch file1.txt file2.txt       # Créer plusieurs fichiers
touch {1..10}.txt               # Crée 1.txt, 2.txt, ..., 10.txt
touch file{A..Z}.txt            # fileA.txt à fileZ.txt

# Options touch
touch -c file.txt               # N'crée pas si n'existe pas
touch -t 202301011200.00 file   # Définir date/heure spécifique
touch -d "2 hours ago" file     # Date relative
touch -r ref.txt file.txt       # Copier timestamp de ref.txt

# Créer répertoires
mkdir dir
mkdir -p path/to/deep/dir       # Créer tous parents nécessaires
mkdir -v dir                    # Verbose (affiche création)
mkdir -m 755 dir                # Avec permissions spécifiques
mkdir dir{1..5}                 # dir1, dir2, dir3, dir4, dir5
mkdir -p project/{src,tests,docs}

# === COPIER, DÉPLACER, SUPPRIMER ===

# Copier
cp source.txt dest.txt
cp source.txt /path/to/dest/
cp file1 file2 file3 dest_dir/
cp -r dir1/ dir2/               # Copier répertoire (récursif)
cp -a source/ dest/             # Archive mode (préserve tout)
cp -u source dest               # Seulement si source plus récent
cp -i source dest               # Interactif (demande confirmation)
cp -n source dest               # Ne pas écraser
cp -v source dest               # Verbose
cp -p source dest               # Préserve attributs
cp -L source dest               # Suivre symlinks

# Copier avec rsync (plus puissant)
rsync -av source/ dest/         # Archive + verbose
rsync -avz source/ dest/        # Avec compression
rsync -av --progress source/ dest/
rsync -av --exclude='*.log' source/ dest/
rsync -av --delete source/ dest/  # Synchronisation (supprime dans dest)

# Déplacer/Renommer
mv old.txt new.txt              # Renommer
mv file.txt /path/to/dest/      # Déplacer
mv file1 file2 file3 dest_dir/
mv -i source dest               # Interactif
mv -u source dest               # Seulement si plus récent
mv -v source dest               # Verbose
mv -n source dest               # Ne pas écraser

# Supprimer
rm file.txt
rm file1 file2 file3
rm -r dir/                      # Répertoire (récursif)
rm -rf dir/                     # Force + récursif (ATTENTION!)
rm -i file.txt                  # Interactif
rm -v file.txt                  # Verbose
rm -- -file.txt                 # Fichier commençant par -
rm ./-file.txt                  # Alternative

# Supprimer en toute sécurité
trash file.txt                  # Envoyer à la corbeille (si trash-cli installé)
rm -I *.txt                     # Demande confirmation pour >3 fichiers

# Vider répertoire mais garder la structure
find dir/ -type f -delete
rm -rf dir/* dir/.*             # ATTENTION: supprime tout

# === LIENS SYMBOLIQUES & HARD LINKS ===

# Créer lien symbolique (symlink)
ln -s /path/to/original link_name
ln -s ../file.txt link.txt      # Relatif
ln -sf original link            # Force (écrase si existe)
ln -sv original link            # Verbose

# Créer hard link
ln original hardlink

# Différences:
# Symlink: pointeur vers fichier (peut traverser systèmes de fichiers)
# Hard link: référence directe aux données (même inode, même filesystem)

# Afficher cible d'un symlink
readlink link_name
readlink -f link_name           # Chemin absolu résolu
ls -l link_name                 # Affiche aussi la cible

# Trouver tous les symlinks
find /path -type l
find /path -type l -ls

# Trouver symlinks cassés
find /path -xtype l

Voici **deux grands énoncés d’exercices complets**, chacun couvrant *toute* la section « Navigation & Système de fichiers » (déplacement, listing, création, copie, suppression, liens symboliques).
Ils sont conçus comme **projets pratiques** qui mobilisent **toutes les commandes** de la section.

---

# [NOTE] **Exercice 1 — Gestion complète d’un mini-projet en ligne de commande**

Vous devez organiser un petit projet nommé **`mon_projet`** uniquement avec les commandes Linux vues dans la section.
L’objectif est de manipuler : navigation, création, déplacement, copie, suppression, filtres, arborescences, symlinks, etc.

### [OBJECTIF] *Objectifs*

* Naviguer dans l’arborescence avec `cd`, `pwd`
* Créer fichiers et dossiers avec `touch` et `mkdir`
* Lister et filtrer avec `ls`
* Copier/déplacer/supprimer avec `cp`, `mv`, `rm`
* Utiliser `tree` pour visualiser
* Créer des liens symboliques et hard links

### [IMPORTANT] **Consignes**

1. Depuis votre HOME, créez un dossier `mon_projet` et déplacez-vous dedans.
   Ajoutez les sous-dossiers :

   ```
   src/
   data/raw/
   data/processed/
   docs/
   tests/
   ```
2. Dans `src/`, créez 10 fichiers `module1.txt` à `module10.txt`.
   Dans `data/raw/`, créez 5 fichiers `inputA.txt` à `inputE.txt`.
3. Listez uniquement les fichiers se terminant par un chiffre dans `src/`.
   Affichez aussi la liste triée par taille, puis par date.
4. Copiez tous les fichiers de `src/` vers `data/processed/`, mais :

   * en préservant les attributs (`cp -a`)
   * en affichant les opérations (`-v`)
5. Déplacez `module10.txt` vers `docs/` et renommez-le `documentation.txt`.
6. Créez un symlink nommé `latest_raw` qui pointe vers `data/raw/`.
   Créez un hardlink de `documentation.txt` dans `tests/`.
7. Supprimez **uniquement** les fichiers de `data/raw/` mais conservez la structure.
   Utilisez `find -type f -delete`.
8. Affichez toute l’arborescence du projet avec `tree -L 3`.

---

# [NOTE] **Exercice 2 — Synchronisation & maintenance d’un répertoire utilisateur**

Vous êtes chargé de maintenir un répertoire `~/backup_etudiant`.
Vous devez synchroniser, nettoyer, trier et organiser les fichiers — uniquement avec les commandes étudiées.

### [OBJECTIF] *Objectifs*

* Utiliser `rsync` pour synchronisation
* Manipuler symlinks vs hard links
* Utiliser `ls` avancé (`--group-directories-first`, tri extensions…)
* Supprimer avec sécurité (`rm -I`)
* Naviguer efficacement avec `cd -`, `cd ~`, etc.

### [IMPORTANT] **Consignes**

1. Dans votre HOME, créez trois dossiers :

   ```
   cours/
   cours_old/
   backup_etudiant/
   ```

   Dans `cours/`, créez :

   * `note1.txt`, `note2.txt`, `note3.txt`
   * un sous-dossier `images/` contenant 3 fichiers `img1.png`, `img2.png`, `img3.png`
2. Copiez tout le contenu de `cours/` vers `cours_old/` en mode archive (`cp -a`).
   Vérifiez les différences de dates et tailles avec `ls -l`.
3. Synchronisez `cours/` vers `backup_etudiant/` avec :

   ```
   rsync -av --delete cours/ backup_etudiant/
   ```

   puis ajoutez un fichier dans `cours/` et resynchronisez.
4. Créez un symlink `cours_link` vers `cours/`.
   Créez aussi un hard link `note3_backup` dans `backup_etudiant/` pointant vers `cours/note3.txt`.
5. Listez le dossier `backup_etudiant/` :

   * répertoires en premier
   * tri par extension
   * affichage des inodes pour vérifier hard link
6. Supprimez uniquement les `.txt` dans `cours_old/` après confirmation sécurisée (`rm -I`).
7. Affichez :

   * le chemin logique et physique du dossier courant (`pwd -L` / `pwd -P`)
   * tous les liens symboliques dans votre HOME avec :
     `find ~ -type l`
   * les liens symboliques cassés
8. Affichez la structure générale avec `tree -d`.



[OK] AFFICHAGE & MANIPULATION DE FICHIERS

# === LIRE FICHIERS ===

# Afficher contenu complet
cat file.txt
cat file1.txt file2.txt         # Concaténer plusieurs fichiers
cat -n file.txt                 # Avec numéros de lignes
cat -b file.txt                 # Numéros seulement lignes non-vides
cat -A file.txt                 # Afficher tous caractères spéciaux
cat -s file.txt                 # Supprimer lignes vides multiples

# Afficher début de fichier
head file.txt                   # 10 premières lignes
head -n 20 file.txt             # 20 premières lignes
head -n -5 file.txt             # Tout sauf 5 dernières lignes
head -c 100 file.txt            # 100 premiers octets

# Afficher fin de fichier
tail file.txt                   # 10 dernières lignes
tail -n 20 file.txt             # 20 dernières lignes
tail -n +10 file.txt            # Depuis ligne 10
tail -f file.txt                # Suivre fichier en temps réel
tail -F file.txt                # Suit même si fichier recréé
tail -f file.txt --pid=12345    # Arrête quand processus 12345 termine

# Afficher avec pagination
less file.txt                   # Navigation avancée
more file.txt                   # Pagination basique

# Commandes dans less:
# Espace: page suivante
# b: page précédente
# /pattern: rechercher
# n: occurrence suivante
# N: occurrence précédente
# g: début du fichier
# G: fin du fichier
# q: quitter

# Options less utiles
less -N file.txt                # Avec numéros de lignes
less -S file.txt                # Ne pas wrapper lignes longues
less +F file.txt                # Mode follow (comme tail -f)
less -R file.txt                # Interpréter couleurs ANSI

# Afficher fichiers binaires
xxd file.bin                    # Hexdump
hexdump -C file.bin
od -x file.bin                  # Octal dump

# Compter
wc file.txt                     # Lignes, mots, octets
wc -l file.txt                  # Seulement lignes
wc -w file.txt                  # Seulement mots
wc -c file.txt                  # Seulement octets
wc -m file.txt                  # Seulement caractères
wc -L file.txt                  # Longueur ligne la plus longue

# === RECHERCHE DANS FICHIERS ===

# grep - recherche de patterns
grep "pattern" file.txt
grep -i "pattern" file.txt      # Insensible à la casse
grep -r "pattern" dir/          # Récursif
grep -n "pattern" file.txt      # Avec numéros de lignes
grep -v "pattern" file.txt      # Inverser (lignes ne contenant PAS pattern)
grep -c "pattern" file.txt      # Compter occurrences
grep -l "pattern" *.txt         # Seulement noms de fichiers
grep -w "word" file.txt         # Mot complet seulement
grep -A 3 "pattern" file.txt    # 3 lignes après
grep -B 3 "pattern" file.txt    # 3 lignes avant
grep -C 3 "pattern" file.txt    # 3 lignes avant et après
grep -E "regex" file.txt        # Expressions régulières étendues
grep -P "regex" file.txt        # Perl regex
grep -o "pattern" file.txt      # Seulement partie correspondante

# Recherche multiple
grep -e "pattern1" -e "pattern2" file.txt
grep "pattern1\|pattern2" file.txt

# Exclure fichiers/dossiers
grep -r "pattern" --exclude="*.log" dir/
grep -r "pattern" --exclude-dir=node_modules dir/

# Alternatives modernes
rg "pattern" dir/               # ripgrep (très rapide, nécessite install)
rg -i "pattern"                 # Insensible casse
rg -l "pattern"                 # Seulement noms fichiers
ag "pattern" dir/               # silver searcher (nécessite install)

# === ÉDITION DE FICHIERS ===

# Éditeurs en ligne de commande
nano file.txt                   # Éditeur simple
vim file.txt                    # Éditeur puissant
vi file.txt                     # Vi (ancêtre de vim)
emacs file.txt                  # Emacs

# Commandes nano:
# Ctrl+O: sauvegarder
# Ctrl+X: quitter
# Ctrl+K: couper ligne
# Ctrl+U: coller
# Ctrl+W: rechercher

# Commandes vim basiques:
# i: mode insertion
# Esc: mode normal
# :w: sauvegarder
# :q: quitter
# :wq ou :x: sauvegarder et quitter
# :q!: quitter sans sauvegarder
# dd: supprimer ligne
# yy: copier ligne
# p: coller
# u: undo
# Ctrl+r: redo
# /pattern: rechercher
# :%s/old/new/g: remplacer tout

# sed - édition de flux
sed 's/old/new/' file.txt       # Remplacer première occurrence
sed 's/old/new/g' file.txt      # Remplacer toutes occurrences
sed 's/old/new/gi' file.txt     # Insensible casse
sed -i 's/old/new/g' file.txt   # Modifier fichier en place
sed -i.bak 's/old/new/g' file.txt  # Avec backup
sed '3d' file.txt               # Supprimer ligne 3
sed '1,5d' file.txt             # Supprimer lignes 1-5
sed -n '10,20p' file.txt        # Afficher lignes 10-20
sed '/pattern/d' file.txt       # Supprimer lignes contenant pattern
sed 's/^/prefix_/' file.txt     # Ajouter préfixe à chaque ligne
sed 's/$/suffix/' file.txt      # Ajouter suffixe

# awk - traitement de texte puissant
awk '{print $1}' file.txt       # Afficher première colonne
awk '{print $1, $3}' file.txt   # Colonnes 1 et 3
awk -F: '{print $1}' /etc/passwd  # Délimiteur personnalisé
awk 'NR==5' file.txt            # Ligne 5
awk 'NR>=5 && NR<=10' file.txt  # Lignes 5-10
awk '/pattern/' file.txt        # Lignes contenant pattern
awk '{sum+=$1} END {print sum}' file.txt  # Somme colonne 1
awk 'length>80' file.txt        # Lignes de plus de 80 caractères
awk '{print NF}' file.txt       # Nombre de colonnes par ligne

# cut - extraire colonnes
cut -d: -f1 /etc/passwd         # Première colonne (délimiteur :)
cut -d, -f1,3 file.csv          # Colonnes 1 et 3
cut -c1-10 file.txt             # Caractères 1-10
cut -f2- file.txt               # Colonne 2 jusqu'à la fin

# sort - trier
sort file.txt                   # Tri alphabétique
sort -n file.txt                # Tri numérique
sort -r file.txt                # Ordre inverse
sort -u file.txt                # Unique (supprime doublons)
sort -k2 file.txt               # Trier par colonne 2
sort -t: -k3 -n /etc/passwd     # Délimiteur perso, colonne 3, numérique
sort -h file.txt                # Tri "human" (1K, 1M, etc.)

# uniq - supprimer doublons adjacents
uniq file.txt                   # Supprimer doublons
uniq -c file.txt                # Compter occurrences
uniq -d file.txt                # Seulement doublons
uniq -u file.txt                # Seulement uniques
sort file.txt | uniq            # Supprimer TOUS doublons

# tr - transformer caractères
tr 'a-z' 'A-Z' < file.txt       # Minuscules vers majuscules
tr -d '\r' < file.txt           # Supprimer caractères
tr -s ' ' < file.txt            # Squeeze espaces multiples
tr '\n' ',' < file.txt          # Remplacer newlines par virgules

# paste - fusionner lignes
paste file1.txt file2.txt       # Colonnes côte à côte
paste -d, file1.txt file2.txt   # Avec délimiteur
paste -s file.txt               # Tout sur une ligne

# join - jointure de fichiers
join -t: -1 1 -2 1 file1.txt file2.txt

# === COMPRESSION & ARCHIVAGE ===

# tar - archivage
tar -cvf archive.tar dir/       # Créer archive
tar -cvzf archive.tar.gz dir/   # Créer archive gzip
tar -cvjf archive.tar.bz2 dir/  # Créer archive bzip2
tar -cvJf archive.tar.xz dir/   # Créer archive xz
tar -xvf archive.tar            # Extraire
tar -xvzf archive.tar.gz        # Extraire gzip
tar -xvf archive.tar -C /path/  # Extraire vers chemin spécifique
tar -tvf archive.tar            # Lister contenu
tar -xvf archive.tar file.txt   # Extraire fichier spécifique
tar --exclude='*.log' -cvzf archive.tar.gz dir/

# Options tar:
# c: créer
# x: extraire
# t: lister
# v: verbose
# f: fichier
# z: gzip
# j: bzip2
# J: xz

# gzip - compression
gzip file.txt                   # Compresser (remplace original)
gzip -k file.txt                # Garder original
gzip -9 file.txt                # Compression maximale
gzip -d file.txt.gz             # Décompresser
gunzip file.txt.gz              # Décompresser (équivalent)
gzip -r dir/                    # Récursif
gzip -l file.txt.gz             # Info compression

# bzip2 - compression (meilleure que gzip)
bzip2 file.txt
bzip2 -k file.txt               # Garder original
bzip2 -d file.txt.bz2
bunzip2 file.txt.bz2

# xz - compression (meilleure que bzip2)
xz file.txt
xz -k file.txt
xz -d file.txt.xz
unxz file.txt.xz

# zip - compression compatible Windows
zip archive.zip file.txt
zip -r archive.zip dir/         # Récursif
zip -e archive.zip file.txt     # Avec mot de passe
unzip archive.zip
unzip -l archive.zip            # Lister contenu
unzip archive.zip -d /path/     # Extraire vers chemin

# Autres formats
7z a archive.7z dir/            # Créer archive 7z
7z x archive.7z                 # Extraire
rar a archive.rar dir/          # Créer RAR
unrar x archive.rar             # Extraire RAR


Voici **deux grands exercices complets**, parfaitement adaptés à un débutant venant d’installer Linux (donc très peu de fichiers), mais qui couvrent **toute la section** : lecture, recherche, édition, transformation et compression.

Chaque exercice est réaliste, progressif et exploite *presque toutes* les commandes listées.

Je te fournis ensuite **les corrigés détaillés**.

---

# [OK] **EXERCICE 1 — Analyse complète d’un dossier texte**

## **Énoncé**

On te donne un petit dossier contenant seulement **3 fichiers** :

```
documents/
├── intro.txt
├── notes.txt
└── system.log
```

Tu dois réaliser une analyse complète de ces fichiers en utilisant **uniquement les commandes Linux** de lecture, recherche et comptage vues dans le cours.

### - **1. Lecture et inspection**

1. Affiche le contenu complet de *intro.txt*.
2. Affiche les **20 premières lignes** de *system.log*.
3. Affiche **les lignes 10 à 20** de *notes.txt*.
4. Affiche *system.log* avec **numéros de lignes**.
5. Affiche *notes.txt* avec `less`, puis :

   * va à la fin du fichier
   * remonte d’une page
   * cherche le mot “error”

### - **2. Recherches**

6. Trouve toutes les lignes contenant "error" dans *system.log*.
7. Trouve toutes les occurrences du mot **exact** “INFO”.
8. Affiche les 3 lignes **avant et après** chaque occurrence de “Failed”.
9. Recherche dans le dossier “documents/” le terme "warning", mais **sans** chercher dans les fichiers `.log`.

### - **3. Compter**

10. Compte les lignes, mots et caractères de *intro.txt*.
11. Trouve les **lignes les plus longues** de *notes.txt*.
12. Compte le nombre d’occurrences du mot “user” dans *system.log*.

### - **4. Extraction**

13. Extrais la **première colonne** de *system.log* (par exemple la date).
14. Extrais les caractères **1 à 20** de chaque ligne de *intro.txt*.

### - **5. Résumé final**

15. Crée un fichier `rapport.txt` contenant :

* le nombre de lignes de chaque fichier
* le nombre de “error” dans *system.log*
* les 5 premières lignes de *notes.txt*

---

# [OBJECTIF] **EXERCICE 2 — Manipulation, modification et compression**

## **Énoncé**

Toujours dans le même dossier `documents/`, tu dois maintenant **modifier**, **transformer** et **archiver** les fichiers.

### - **1. Nettoyage et transformation**

1. Crée un fichier `clean_notes.txt` contenant *notes.txt* :

   * sans lignes vides multiples
   * toutes les lettres en majuscules

2. Dans *system.log* :

   * supprime toutes les lignes contenant “DEBUG”
   * remplace “ERROR” par “ERR:”
   * sauvegarde le résultat dans `system_clean.log`

3. Dans *intro.txt* :

   * ajoute le préfixe `">>> "` au début de chaque ligne
   * ajoute le suffixe `" <<<"` à la fin

### - **2. Jointure et fusion**

4. Crée un fichier `merge.txt` contenant :

   * intro.txt
   * puis notes.txt
   * séparés par une ligne contenant `-----`

5. Place côte à côte (`paste`) :

   * intro.txt
   * system_clean.log
     et sauvegarde dans `combined.txt`.

### - **3. Tri et unicité**

6. Trie *notes.txt* :

   * alphabétiquement
   * puis numériquement
   * puis en supprimant les doublons

### - **4. Compression / Archivage**

7. Crée une archive `documents.tar.gz` contenants tous les fichiers.
8. Crée aussi une archive ZIP `backup.zip`.
9. Liste le contenu des deux archives.
10. Extrais uniquement `system_clean.log` depuis l’archive TAR.

---


[OK] PERMISSIONS & PROPRIÉTÉ

# === COMPRENDRE LES PERMISSIONS ===

# Format: drwxrwxrwx
# d: type (d=directory, -=file, l=link)
# rwx: user (propriétaire)
# rwx: group (groupe)
# rwx: others (autres)
#
# r (read): 4
# w (write): 2
# x (execute): 1

# === CHMOD - MODIFIER PERMISSIONS ===

# Mode symbolique
chmod u+x file.txt              # Ajouter exec pour user
chmod g-w file.txt              # Retirer write pour group
chmod o=r file.txt              # Définir others à read only
chmod a+r file.txt              # Ajouter read pour all
chmod u+x,g+x file.txt          # Multiple
chmod +x file.txt               # Ajouter exec pour all (raccourci)

# Mode numérique
chmod 755 file.txt              # rwxr-xr-x
chmod 644 file.txt              # rw-r--r--
chmod 600 file.txt              # rw-------
chmod 777 file.txt              # rwxrwxrwx (ÉVITER!)
chmod 700 dir/                  # rwx------ pour dir

# Permissions courantes:
# 644: fichiers normaux (rw-r--r--)
# 755: fichiers exécutables et dossiers (rwxr-xr-x)
# 600: fichiers privés (rw-------)
# 700: dossiers privés (rwx------)
# 777: tout le monde peut tout faire (DANGEREUX!)

# Récursif
chmod -R 755 dir/               # Récursif

# Permissions spéciales
chmod u+s file                  # SUID
chmod g+s dir                   # SGID
chmod +t dir                    # Sticky bit
chmod 4755 file                 # SUID + 755
chmod 2755 dir                  # SGID + 755
chmod 1755 dir                  # Sticky + 755

# === CHOWN - MODIFIER PROPRIÉTAIRE ===

# Changer propriétaire
sudo chown user file.txt
sudo chown user:group file.txt
sudo chown :group file.txt      # Seulement groupe
sudo chown -R user:group dir/   # Récursif

# Copier ownership d'un autre fichier
sudo chown --reference=ref.txt file.txt

# === CHGRP - MODIFIER GROUPE ===

sudo chgrp group file.txt
sudo chgrp -R group dir/

# === UMASK - PERMISSIONS PAR DÉFAUT ===

# Afficher umask
umask
umask -S                        # Format symbolique

# Définir umask
umask 022                       # Défaut: 755 pour dirs, 644 pour files
umask 077                       # Restrictif: 700 pour dirs, 600 pour files

# Calcul:
# Directories: 777 - umask
# Files: 666 - umask
# Exemple umask 022:
#   Dirs: 777 - 022 = 755
#   Files: 666 - 022 = 644

# === ACL - PERMISSIONS AVANCÉES ===

# Installer ACL (si nécessaire)
sudo apt install acl            # Debian/Ubuntu
sudo yum install acl            # RedHat/CentOS

# Afficher ACL
getfacl file.txt

# Définir ACL
setfacl -m u:username:rwx file.txt
setfacl -m g:groupname:rx file.txt
setfacl -m o::r file.txt
setfacl -R -m u:user:rwx dir/   # Récursif

# Supprimer ACL
setfacl -x u:username file.txt
setfacl -b file.txt             # Supprimer toutes les ACL

# ACL par défaut (pour nouveaux fichiers dans dir)
setfacl -d -m u:user:rwx dir/

# === ATTRIBUTS DE FICHIERS ===

# Afficher attributs
lsattr file.txt

# Modifier attributs
sudo chattr +i file.txt         # Immutable (non modifiable)
sudo chattr -i file.txt         # Retirer immutable
sudo chattr +a file.txt         # Append only
sudo chattr +A file.txt         # No atime update

# Attributs utiles:
# i: immutable (ne peut pas être modifié/supprimé)
# a: append-only (peut seulement ajouter)
# A: no atime (pas de mise à jour access time)
# s: secure deletion (écrasement sécurisé)
# u: undeletable (peut être récupéré après suppression)


Voici **4 grands énoncés d’exercices complets**, parfaitement adaptés à quelqu’un qui vient *juste d’installer Linux* (donc très peu de fichiers), mais qui couvrent **toute la section Permissions & Propriété** :

* chmod (symbolique & numérique)
* chown / chgrp
* umask
* ACL
* attributs spéciaux (chattr)

Les énoncés sont réalistes, progressifs et exploitent un petit environnement minimal.

---

# [BLEU] **EXERCICE 1 — Laboratoire complet sur les permissions (chmod)**

### **Objectif : maîtriser toutes les permissions user / group / others en symbolique et numérique.**

On te donne un petit dossier créé avec :

```
mkdir lab
cd lab
touch file1.txt file2.txt script.sh
mkdir private shared
```

Réalise les tâches suivantes :

### - Partie A — Lecture & analyse

1. Affiche les permissions actuelles de tous les fichiers dans `lab/`.
2. Explique ce que signifie le format `-rw-r--r--` et `drwxr-xr-x`.

### - Partie B — Modifications symboliques

3. Ajoute l’exécution à `script.sh` pour l’utilisateur uniquement.
4. Retire l’écriture pour le groupe sur `file1.txt`.
5. Donne la lecture à “others” sur `shared/`.

### - Partie C — Modifications numériques

6. Mets `file2.txt` en permissions **600**.
7. Mets `private/` en **700**.
8. Convertis les permissions `rwxr-xr--` en mode numérique. (Écris la réponse.)

### - Partie D — Récursif

9. Donne les permissions **755** à tout le dossier `shared/` de manière récursive.

### - Partie E — Permissions spéciales

10. Configure `shared/` avec le **SGID**.
11. Configure `private/` avec le **sticky bit**.
12. Installe un SUID sur `script.sh`.

---

# [BLEU] **EXERCICE 2 — Propriété & groupes (chown / chgrp)**

### **Objectif : comprendre utilisateurs, groupes, ownership et héritage.**

On te donne un dossier :

```
mkdir owners
cd owners
touch report.txt data.csv
mkdir archive
```

Imagine qu’il existe 2 utilisateurs sur le système : **user1** et **user2**, et les groupes **teamA** et **teamB**.

Réalise les opérations suivantes :

### - Partie A — Changement de propriétaire

1. Donne `report.txt` à l’utilisateur `user1`.
2. Donne `data.csv` au groupe `teamA`.

### - Partie B — Chown combiné

3. Donne `archive/` à `user2:teamB`.
4. Fais-le de manière récursive.

### - Partie C — Référence

5. Crée un fichier `model.txt`, modifie son propriétaire, puis copie ces propriétés sur `report.txt` **avec la commande `--reference`**.

### - Partie D — Vérification

6. Affiche les propriétaires avant et après chaque action (le faire fait partie de l’exercice).

---

# [BLEU] **EXERCICE 3 — UMASK et permissions par défaut**

### **Objectif : comprendre comment Linux détermine les permissions des *nouveaux* fichiers.**

Utilise un dossier vide :

```
mkdir umask_test
cd umask_test
```

Réalise les actions suivantes :

### - Partie A — Inspecter

1. Affiche le umask actuel en format normal et symbolique.
2. Explique ce que signifie une umask de `022`.

### - Partie B — Manipuler

3. Change temporairement le umask à `077`.
4. Crée un fichier `secret.txt` et note ses permissions.
5. Change le umask à `002`.
6. Crée un dossier `team_folder` et note ses permissions.

### - Partie C — Calcul

7. Calcule manuellement les permissions par défaut pour :

   * fichiers avec umask 027
   * dossiers avec umask 027
8. Vérifie avec Linux en créant 1 fichier et 1 dossier.

### - Partie D — Explication

9. Explique pourquoi les fichiers n’ont jamais automatiquement le bit `x`.

---

# [BLEU] **EXERCICE 4 — ACL & attributs avancés (setfacl / getfacl / chattr)**

### **Objectif : découvrir les permissions avancées et les attributs de sécurité.**

Crée un environnement minimal :

```
mkdir secure
cd secure
touch note.txt
```

Imagine que les utilisateurs **alice** et **bob** existent sur le système.

### - Partie A — ACL basiques

1. Donne à **alice** la permission `rwx` sur `note.txt`.
2. Donne à **bob** la permission `rx`.
3. Affiche les ACL du fichier.

### - Partie B — ACL par défaut

4. Crée un dossier `project/`.
5. Configure une ACL par défaut :

   * alice : `rwx`
   * bob : `rx`
6. Crée un fichier dans `project/` et vérifie l’héritage.

### - Partie C — Suppression

7. Supprime l’ACL de bob uniquement.
8. Supprime toutes les ACL du fichier.

### - Partie D — Chattr (attributs spéciaux)

9. Mets `note.txt` en mode **immutable**.
10. Tente de le modifier (Linux doit refuser).
11. Retire l’attribut immutable.
12. Mets-le en mode **append-only**.
13. Essaye d’écraser le fichier (ça doit échouer) mais ajoute une ligne (ça doit fonctionner).

---


[OK] RECHERCHE DE FICHIERS

# === FIND - RECHERCHE PUISSANTE ===

# Recherche basique
find /path -name "filename"
find /path -name "*.txt"
find . -name "file*"
find / -name "nginx.conf" 2>/dev/null  # Ignorer erreurs

# Options de nom
find /path -iname "*.txt"       # Insensible casse
find /path -name "*.txt" -o -name "*.log"  # OR
find /path -not -name "*.txt"   # Négation
find /path ! -name "*.txt"      # Négation (alternative)

# Par type
find /path -type f              # Fichiers
find /path -type d              # Répertoires
find /path -type l              # Liens symboliques
find /path -type s              # Sockets
find /path -type p              # Named pipes

# Par taille
find /path -size +100M          # Plus de 100MB
find /path -size -10k           # Moins de 10KB
find /path -size 50M            # Exactement 50MB
find /path -size +1G -size -5G  # Entre 1GB et 5GB

# Unités: c (bytes), k (KB), M (MB), G (GB)

# Par temps
find /path -mtime -7            # Modifié derniers 7 jours
find /path -mtime +30           # Modifié il y a plus de 30 jours
find /path -mmin -60            # Modifié dernières 60 minutes
find /path -atime -7            # Accédé derniers 7 jours
find /path -ctime -7            # Métadata changée derniers 7 jours

# Par permissions
find /path -perm 644            # Permissions exactes
find /path -perm -644           # Au moins ces permissions
find /path -perm /644           # N'importe laquelle de ces permissions
find /path -perm /u=w,g=w       # Writable par user OU group

# Par propriétaire
find /path -user username
find /path -group groupname
find /path -uid 1000
find /path -gid 1000
find /path -nouser              # Sans propriétaire
find /path -nogroup             # Sans groupe

# Profondeur
find /path -maxdepth 2          # Max 2 niveaux
find /path -mindepth 1          # Min 1 niveau
find /path -maxdepth 1 -type f  # Seulement ce niveau

# Actions
find /path -name "*.log" -delete
find /path -name "*.txt" -exec cat {} \;
find /path -name "*.txt" -exec mv {} /dest/ \;
find /path -name "*.txt" -ok rm {} \;  # Demande confirmation
find /path -type f -exec chmod 644 {} \;
find /path -type d -exec chmod 755 {} \;

# {} : représente fichier trouvé
# \; : fin de commande exec
# + : passer plusieurs fichiers à la fois (plus efficace)

find /path -name "*.txt" -exec grep "pattern" {} +

# Multiple critères
find /path -name "*.log" -size +100M -mtime +30

# Fichiers vides
find /path -empty
find /path -type f -empty       # Fichiers vides
find /path -type d -empty       # Répertoires vides

# Exclure répertoires
find /path -name node_modules -prune -o -name "*.js" -print
find /path -path "*/node_modules/*" -prune -o -type f -print

# Par contenu (nécessite -exec grep)
find /path -type f -exec grep -l "pattern" {} \;

# === LOCATE - RECHERCHE RAPIDE ===

# Mettre à jour base de données
sudo updatedb

# Rechercher
locate filename
locate "*.conf"
locate -i filename              # Insensible casse
locate -n 10 filename           # Limiter à 10 résultats
locate -c filename              # Compter résultats
locate -e filename              # Seulement si existe encore
locate -r "regex"               # Avec regex

# Statistiques
locate -S

# === WHEREIS - TROUVER BINAIRES ===

whereis command
whereis -b command              # Seulement binaire
whereis -m command              # Seulement man pages
whereis -s command              # Seulement sources

# === WHICH - TROUVER DANS PATH ===

which command
which -a command                # Tous les matches

# === TYPE - INFO SUR COMMANDE ===

type command
type -a command                 # Tous les types
type -t command                 # Type seulement



Voici **4 grands énoncés d’exercices détaillés** pour la section **Recherche de fichiers**, adaptés à une **installation Linux récente**, donc avec peu de fichiers et utilisateurs. Chaque exercice couvre un aspect de la section : `find`, `locate`, `whereis`, `which`, `type`.

---

# [BLEU] **EXERCICE 1 — Recherche de fichiers avec `find` (bases et filtres simples)**

## **Énoncé**

1. Dans votre **home directory**, créez quelques fichiers de test :

   * `file1.txt`, `file2.log`, `file3.txt`
   * `empty.txt` (fichier vide)
   * un répertoire `testdir` avec un fichier `inside.txt`

2. Utilisez `find` pour :
   a) Lister tous les fichiers `.txt`.
   b) Lister tous les fichiers `.log`.
   c) Lister tous les fichiers **insensibles à la casse** `.TXT`.
   d) Lister **les fichiers vides**.
   e) Lister tous les fichiers **dans `testdir` uniquement**, sans descendre plus bas.

3. Supprimez le fichier `empty.txt` via `find` avec l’action `-delete`.

4. Affichez le contenu de tous les fichiers `.txt` avec `find ... -exec cat {} \;`.

---

# [BLEU] **EXERCICE 2 — Recherche avancée avec `find` (taille, temps, permissions, propriétaire)**

## **Énoncé**

1. Créez quelques fichiers supplémentaires :

   * `bigfile.txt` (~1MB rempli avec du texte)
   * `oldfile.log` (modifiez sa date pour qu’il apparaisse comme ancien, `touch -d "40 days ago" oldfile.log`)

2. Utilisez `find` pour :
   a) Lister les fichiers **plus grands que 500KB**.
   b) Lister les fichiers **modifiés il y a plus de 30 jours**.
   c) Lister les fichiers avec **permissions 644**.
   d) Lister les fichiers appartenant à votre **utilisateur courant**.

3. Testez une combinaison : trouver tous les fichiers `.log` plus grands que 100KB et plus anciens que 30 jours.

---

# [BLEU] **EXERCICE 3 — Recherche rapide et localisation de commandes**

## **Énoncé**

1. Mettre à jour la base de `locate` avec `sudo updatedb`.

2. Rechercher avec `locate` :
   a) Tous les fichiers contenant `bashrc` dans leur nom.
   b) Limiter à 5 résultats.
   c) Compter combien de fichiers contiennent `passwd`.

3. Utilisez `whereis` pour :
   a) Trouver le binaire de `ls`.
   b) Trouver la man page de `grep`.
   c) Trouver les sources de `cat` (si disponibles).

4. Utilisez `which` pour vérifier :
   a) Le chemin exact de `python3`.
   b) Tous les chemins possibles pour `ls` avec `which -a`.

5. Utilisez `type` pour :
   a) Vérifier si `ls` est un alias ou un binaire.
   b) Vérifier tous les types possibles pour `python3`.

---

# [BLEU] **EXERCICE 4 — Actions automatiques sur fichiers trouvés avec `find`**

## **Énoncé**

1. Créez un répertoire `proj` avec :

   * `file1.txt`, `file2.txt`, `file3.log`
   * Un sous-répertoire `subdir` avec `inside1.txt`

2. Avec `find`, réalisez les actions suivantes :
   a) Lister tous les fichiers `.txt` et les **déplacer** vers un nouveau répertoire `txt_backup`.
   b) Lister tous les fichiers `.log` et demander confirmation avant de les supprimer (`-ok rm {} \;`).
   c) Changer les permissions de tous les fichiers `.txt` à **644** et des répertoires à **755**.
   d) Chercher tous les fichiers contenant le mot `TODO` et afficher leur contenu (`-exec grep -l "TODO" {} \;`).
   e) Exclure le répertoire `subdir` de la recherche des `.txt` avec `-prune`.

---



[OK] PROCESSUS & GESTION SYSTÈME

# === VOIR PROCESSUS ===

# ps - processus
ps                              # Processus du terminal actuel
ps aux                          # Tous processus (BSD style)
ps -ef                          # Tous processus (Unix style)
ps -u username                  # Processus d'un utilisateur
ps -C processname               # Processus par nom
ps --forest                     # Vue arborescente
ps aux --sort=-%mem             # Trier par mémoire
ps aux --sort=-%cpu             # Trier par CPU

# Colonnes ps:
# PID: Process ID
# USER: propriétaire
# %CPU: utilisation CPU
# %MEM: utilisation mémoire
# VSZ: mémoire virtuelle
# RSS: mémoire résidente
# STAT: état (R=running, S=sleeping, Z=zombie, T=stopped)
# TIME: temps CPU
# COMMAND: commande

# top - monitoring temps réel
top
top -u username                 # Filtrer par user
top -p 1234                     # Processus spécifique
top -d 5                        # Refresh toutes les 5 secondes

# Commandes dans top:
# q: quitter
# k: kill processus
# r: renice processus
# M: trier par mémoire
# P: trier par CPU
# 1: afficher tous CPU
# h: aide

# htop - top amélioré (nécessite installation)
htop
# Navigation avec flèches, F9 pour kill, F6 pour trier

# === CONTRÔLE PROCESSUS ===

# Lancer processus
command
command &                       # En arrière-plan
nohup command &                 # Continue après déconnexion
nohup command > output.log 2>&1 &

# Jobs (processus du terminal)
jobs                            # Lister jobs
jobs -l                         # Avec PID

# Foreground/Background
fg                              # Ramener dernier job en avant
fg %1                           # Job 1 en avant
bg                              # Continuer dernier job en arrière-plan
bg %1                           # Job 1 en arrière-plan

# Suspendre processus
Ctrl+Z                          # Suspendre processus actuel

# === KILL PROCESSUS ===

# kill - envoyer signal
kill PID                        # SIGTERM (terminaison propre)
kill -9 PID                     # SIGKILL (force, brutal)
kill -15 PID                    # SIGTERM (explicite)
kill -SIGTERM PID               # Avec nom de signal
kill -l                         # Lister tous les signaux

# Signaux courants:
# 1  SIGHUP: hangup
# 2  SIGINT: interrupt (Ctrl+C)
# 9  SIGKILL: kill force (non capturable)
# 15 SIGTERM: terminate (propre)
# 18 SIGCONT: continue
# 19 SIGSTOP: stop
# 20 SIGTSTP: terminal stop (Ctrl+Z)

# killall - kill par nom
killall processname
killall -9 processname
killall -u username             # Tous processus d'un user
killall -i processname          # Interactif

# pkill - kill par pattern
pkill processname
pkill -9 processname
pkill -u username
pkill -f "script.py"            # Pattern sur ligne commande complète

# pgrep - trouver PID par pattern
pgrep processname
pgrep -u username
pgrep -l processname            # Avec nom
pgrep -a processname            # Avec commande complète

# === PRIORITÉ PROCESSUS ===

# nice - lancer avec priorité
nice -n 10 command              # Nice +10 (priorité basse)
nice -n -10 command             # Nice -10 (priorité haute, nécessite root)

# Valeurs nice: -20 (haute priorité) à 19 (basse priorité)
# Défaut: 0

# renice - changer priorité processus existant
renice 10 -p PID
renice 10 -u username
sudo renice -10 -p PID          # Priorité haute (root requis)

# === MONITORING SYSTÈME ===

# uptime - temps de fonctionnement
uptime
uptime -p                       # Format lisible
uptime -s                       # Depuis quand

# free - mémoire
free
free -h                         # Human readable
free -m                         # En MB
free -g                         # En GB
free -s 5                       # Rafraîchir toutes les 5 sec

# vmstat - statistiques système
vmstat                          # Vue d'ensemble
vmstat 5                        # Mise à jour toutes les 5 sec
vmstat -s                       # Statistiques mémoire
vmstat -d                       # Statistiques disque

# iostat - statistiques I/O
iostat
iostat -x                       # Étendu
iostat 5                        # Toutes les 5 sec
iostat -d                       # Seulement disques

# mpstat - statistiques CPU
mpstat
mpstat -P ALL                   # Tous CPU
mpstat 5                        # Toutes les 5 sec

# sar - rapport système (nécessite sysstat)
sar                             # CPU usage
sar -r                          # Mémoire
sar -b                          # I/O
sar -n DEV                      # Network
sar -q                          # Load average

# dmesg - messages kernel
dmesg
dmesg | tail
dmesg | grep -i error
dmesg -T                        # Avec timestamps lisibles
dmesg -w                        # Watch mode
dmesg -l err                    # Seulement erreurs

# === INFORMATIONS SYSTÈME ===

# uname - info système
uname -a                        # Tout
uname -r                        # Version kernel
uname -m                        # Architecture
uname -n                        # Hostname
uname -s                        # Nom système

# hostname - nom machine
hostname
hostname -f                     # FQDN
hostname -i                     # Adresse IP

# lscpu - info CPU
lscpu

# lsmem - info mémoire
lsmem

# lsblk - info disques
lsblk
lsblk -f                        # Avec filesystem
lsblk -o NAME,SIZE,TYPE,MOUNTPOINT

# lspci - périphériques PCI
lspci
lspci -v                        # Verbose
lspci | grep -i vga             # Carte graphique

# lsusb - périphériques USB
lsusb
lsusb -v

# dmidecode - info hardware (nécessite root)
sudo dmidecode
sudo dmidecode -t memory        # Info mémoire
sudo dmidecode -t processor     # Info CPU
sudo dmidecode -t bios          # Info BIOS

# hwinfo - info hardware complète
hwinfo --short

# inxi - info système (nécessite installation)
inxi -F                         # Full info
inxi -b                         # Basic info


Voici **4 grands énoncés d’exercices détaillés** pour la section **Processus & Gestion Système**, adaptés à une **installation Linux fraîche**, donc avec peu de fichiers et peu de processus utilisateurs. Chaque exercice couvre un aspect de la section.

---

# [BLEU] **EXERCICE 1 — Visualisation des processus**

## **Énoncé**

1. Lancez quelques commandes simples en arrière-plan dans votre terminal, par exemple :

   ```bash
   sleep 60 &
   ping -c 4 google.com &
   ```

2. Utilisez `ps` pour :
   a) Lister les processus de votre terminal actuel.
   b) Lister **tous les processus** de votre utilisateur avec `ps -u username`.
   c) Afficher les processus sous forme d’**arborescence** (`ps --forest`).
   d) Trier les processus par **mémoire** et par **CPU** (`ps aux --sort=-%mem`, `ps aux --sort=-%cpu`).

3. Utilisez `top` et `htop` (si installé) pour :
   a) Observer les processus actifs.
   b) Trier par mémoire et CPU.
   c) Filtrer par votre utilisateur.

4. Identifiez le **PID** d’un processus en cours (`sleep`, `ping`) avec `ps` ou `pgrep`.

---

# [BLEU] **EXERCICE 2 — Contrôle et gestion des processus**

## **Énoncé**

1. Lancez un processus en arrière-plan :

   ```bash
   sleep 300 &
   ```

2. Listez tous les jobs avec `jobs` et notez le **numéro du job** et le **PID**.

3. Expérimentez le **foreground/background** :
   a) Suspendez le processus avec `Ctrl+Z`.
   b) Remettez-le en arrière-plan avec `bg %1`.
   c) Ramenez-le au premier plan avec `fg %1`.

4. Testez la **terminaison d’un processus** :
   a) Utilisez `kill PID` pour terminer proprement un `sleep`.
   b) Essayez `kill -9 PID` pour forcer l’arrêt d’un autre processus.
   c) Testez `killall sleep` pour tuer tous les `sleep` restants.
   d) Vérifiez avec `ps` que le processus a disparu.

---

# [BLEU] **EXERCICE 3 — Priorité et monitoring système**

## **Énoncé**

1. Lancez un processus avec une priorité personnalisée :

   ```bash
   nice -n 10 sleep 100 &
   ```

2. Vérifiez sa priorité avec `ps -o pid,ni,cmd -p PID`.

3. Modifiez la priorité d’un processus existant avec `renice` :

   ```bash
   renice 5 -p PID
   ```

   et observez la différence.

4. Observez l’état général du système :
   a) `uptime` pour temps de fonctionnement et load average.
   b) `free -h` pour mémoire.
   c) `vmstat 2 3` pour voir l’activité CPU et mémoire sur 3 cycles de 2 secondes.
   d) `iostat -x 2 3` pour activité disque.
   e) `mpstat -P ALL 2 2` pour CPU par cœur.

5. Notez les valeurs importantes : mémoire libre, charge moyenne, activité CPU.

---

# [BLEU] **EXERCICE 4 — Informations système et périphériques**

## **Énoncé**

1. Récupérez les informations système de base :
   a) `uname -a`, `uname -r`, `uname -m`.
   b) `hostname` et `hostname -i`.

2. Observez le matériel et périphériques :
   a) `lscpu` pour CPU.
   b) `lsmem` pour mémoire.
   c) `lsblk -f` pour disques et partitions.
   d) `lspci | grep -i vga` pour carte graphique.
   e) `lsusb` pour périphériques USB.

3. Si disponible, utilisez `dmidecode` ou `inxi -F` pour avoir un **rapport complet** sur le hardware.

4. Comparez les informations obtenues avec `top` ou `htop` pour relier **CPU, mémoire et processus en cours**.

---



[OK] RÉSEAU

# === CONFIGURATION RÉSEAU ===

# ip - outil moderne (remplace ifconfig)
ip addr                         # Adresses IP
ip a                            # Raccourci
ip addr show eth0               # Interface spécifique
ip link                         # Interfaces réseau
ip link show
ip route                        # Table de routage
ip route show
ip neigh                        # ARP table

# Ajouter/supprimer IP
sudo ip addr add 192.168.1.100/24 dev eth0
sudo ip addr del 192.168.1.100/24 dev eth0

# Activer/désactiver interface
sudo ip link set eth0 up
sudo ip link set eth0 down

# ifconfig - outil traditionnel
ifconfig
ifconfig eth0
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0
sudo ifconfig eth0 up
sudo ifconfig eth0 down

# === CONNECTIVITÉ ===

# ping - tester connectivité
ping google.com
ping -c 4 google.com            # 4 pings seulement
ping -i 2 google.com            # Intervalle 2 secondes
ping -s 1000 google.com         # Taille packet 1000 bytes
ping -W 2 google.com            # Timeout 2 secondes

# traceroute - tracer route
traceroute google.com
traceroute -n google.com        # Sans résolution DNS
traceroute -m 15 google.com     # Max 15 hops

# mtr - traceroute continu
mtr google.com
mtr -r -c 10 google.com         # Rapport 10 cycles

# === DNS ===

# nslookup - requête DNS
nslookup google.com
nslookup google.com 8.8.8.8     # Serveur DNS spécifique

# dig - requête DNS avancée
dig google.com
dig google.com +short           # Résultat court
dig google.com MX               # Enregistrements MX
dig google.com NS               # Serveurs de noms
dig @8.8.8.8 google.com         # Serveur DNS spécifique
dig -x 8.8.8.8                  # Reverse lookup

# host - simple lookup
host google.com
host -t MX google.com

# === CONNEXIONS RÉSEAU ===

# netstat - statistiques réseau (ancien)
netstat -tuln                   # Ports en écoute
netstat -tunap                  # Toutes connexions avec PID
netstat -r                      # Table de routage
netstat -i                      # Interfaces
netstat -s                      # Statistiques

# Options:
# -t: TCP
# -u: UDP
# -l: listening
# -n: numérique (pas de résolution)
# -a: all
# -p: PID/program

# ss - socket statistics (moderne, remplace netstat)
ss -tuln                        # Ports en écoute
ss -tunap                       # Toutes connexions
ss -s                           # Statistiques
ss -o                           # Timers
ss -e                           # Détails socket
ss -m                           # Mémoire
ss dst 192.168.1.100            # Destination spécifique
ss sport = :80                  # Port source
ss dport = :443                 # Port destination

# lsof - list open files (inclus sockets)
sudo lsof -i                    # Toutes connexions
sudo lsof -i :80                # Port spécifique
sudo lsof -i TCP                # Seulement TCP
sudo lsof -i UDP                # Seulement UDP
sudo lsof -u username           # Par utilisateur
sudo lsof -c processname        # Par processus

# === TÉLÉCHARGEMENT ===

# wget - télécharger fichiers
wget URL
wget -O filename URL            # Sauver avec nom spécifique
wget -c URL                     # Continuer téléchargement
wget -b URL                     # Arrière-plan
wget -r URL                     # Récursif (site entier)
wget --limit-rate=200k URL      # Limiter vitesse
wget -i urls.txt                # Liste d'URLs
wget --user=username --password=pass URL
wget -q URL                     # Quiet mode

# curl - transfert de données
curl URL
curl -o filename URL            # Sauver dans fichier
curl -O URL                     # Garder nom original
curl -L URL                     # Suivre redirections
curl -C - URL                   # Continuer téléchargement
curl -I URL                     # Headers seulement
curl -X POST URL                # POST request
curl -d "data" URL              # Avec données
curl -H "Header: value" URL     # Header personnalisé
curl -u user:pass URL           # Authentification
curl -s URL                     # Silent mode
curl -v URL                     # Verbose

# Tester API
curl -X GET https://api.example.com/users
curl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' URL

# === FIREWALL ===

# iptables - firewall (traditionnel)
sudo iptables -L                # Lister règles
sudo iptables -L -n             # Sans résolution DNS
sudo iptables -L -v             # Verbose
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT
sudo iptables -D INPUT 5        # Supprimer règle 5
sudo iptables -F                # Flush toutes règles
sudo iptables-save > rules.txt  # Sauvegarder
sudo iptables-restore < rules.txt

# ufw - uncomplicated firewall (Ubuntu)
sudo ufw status
sudo ufw enable
sudo ufw disable
sudo ufw allow 80
sudo ufw allow 80/tcp
sudo ufw allow from 192.168.1.0/24
sudo ufw deny 23
sudo ufw delete allow 80
sudo ufw reset

# firewalld - firewall (RHEL/CentOS)
sudo firewall-cmd --state
sudo firewall-cmd --list-all
sudo firewall-cmd --add-port=80/tcp
sudo firewall-cmd --add-service=http
sudo firewall-cmd --remove-port=80/tcp
sudo firewall-cmd --reload
sudo firewall-cmd --permanent --add-port=80/tcp

# === SSH ===

# Connexion SSH
ssh user@host
ssh -p 2222 user@host           # Port non-standard
ssh -i ~/.ssh/key.pem user@host # Clé privée spécifique
ssh user@host command           # Exécuter commande distante

# Copier fichiers via SSH
scp file.txt user@host:/path/
scp user@host:/path/file.txt .
scp -r dir/ user@host:/path/    # Récursif
scp -P 2222 file.txt user@host:/path/  # Port non-standard

# rsync via SSH (meilleur que scp)
rsync -avz -e ssh file.txt user@host:/path/
rsync -avz -e "ssh -p 2222" dir/ user@host:/path/

# Générer clés SSH
ssh-keygen                      # RSA par défaut
ssh-keygen -t ed25519           # ED25519 (recommandé)
ssh-keygen -t rsa -b 4096       # RSA 4096 bits
ssh-keygen -t ed25519 -C "email@example.com"

# Copier clé publique vers serveur
ssh-copy-id user@host
ssh-copy-id -i ~/.ssh/key.pub user@host

# Config SSH (~/.ssh/config)
# Host myserver
#     HostName 192.168.1.100
#     User myuser
#     Port 2222
#     IdentityFile ~/.ssh/mykey
# Puis: ssh myserver

# SSH tunnels
ssh -L 8080:localhost:80 user@host      # Local port forwarding
ssh -R 8080:localhost:80 user@host      # Remote port forwarding
ssh -D 1080 user@host                   # Dynamic (SOCKS proxy)

# Maintenir connexion SSH
ssh -o ServerAliveInterval=60 user@host

# === ANALYSE RÉSEAU ===

# tcpdump - capturer packets
sudo tcpdump
sudo tcpdump -i eth0            # Interface spécifique
sudo tcpdump -c 100             # 100 packets
sudo tcpdump -w capture.pcap    # Sauver dans fichier
sudo tcpdump -r capture.pcap    # Lire depuis fichier
sudo tcpdump port 80
sudo tcpdump host 192.168.1.100
sudo tcpdump src 192.168.1.100
sudo tcpdump dst 192.168.1.100
sudo tcpdump tcp
sudo tcpdump udp
sudo tcpdump -n                 # Sans résolution DNS
sudo tcpdump -A                 # ASCII
sudo tcpdump -X                 # Hex et ASCII

# wireshark - GUI pour analyse (nécessite X)
wireshark

# nmap - scan réseau
nmap 192.168.1.100              # Scan basique
nmap -p 80,443 192.168.1.100    # Ports spécifiques
nmap -p 1-1000 192.168.1.100    # Range de ports
nmap -sV 192.168.1.100          # Détecter versions services
nmap -O 192.168.1.100           # Détecter OS
nmap -A 192.168.1.100           # Scan agressif
nmap 192.168.1.0/24             # Scan subnet

# nc (netcat) - couteau suisse réseau
nc -l 1234                      # Écouter sur port 1234
nc host 1234                    # Se connecter
nc -zv host 80                  # Tester port
nc -zv host 1-1000              # Scanner ports
echo "GET / HTTP/1.0" | nc host 80

# iperf - tester bande passante
iperf -s                        # Mode serveur
iperf -c server_ip              # Mode client


Voici **5 grands énoncés d’exercices détaillés** pour la section **Réseau**, adaptés à une **installation Linux fraîche**, en couvrant toutes les sous-sections et avec des instructions concrètes étape par étape.

---

# [BLEU] **EXERCICE 1 — Découverte et configuration des interfaces réseau**

## **Énoncé détaillé**

1. Affichez toutes les interfaces réseau de votre machine :

   ```bash
   ip addr
   ip link show
   ```

   Observez les interfaces `lo`, `eth0` ou `wlan0`.

2. Vérifiez votre **adresse IP actuelle** :

   ```bash
   ip addr show eth0
   ```

3. Activez ou désactivez une interface :

   ```bash
   sudo ip link set eth0 down
   sudo ip link set eth0 up
   ```

   Vérifiez avec `ip link show`.

4. Ajoutez une **adresse IP temporaire** à une interface et testez-la :

   ```bash
   sudo ip addr add 192.168.1.100/24 dev eth0
   ip addr show eth0
   ```

   Puis supprimez-la :

   ```bash
   sudo ip addr del 192.168.1.100/24 dev eth0
   ```

5. Comparez avec l’ancienne méthode `ifconfig` :

   ```bash
   ifconfig
   sudo ifconfig eth0 192.168.1.101 netmask 255.255.255.0
   ifconfig eth0
   sudo ifconfig eth0 down
   sudo ifconfig eth0 up
   ```

---

# [BLEU] **EXERCICE 2 — Tester la connectivité et tracer le réseau**

## **Énoncé détaillé**

1. Testez la connectivité vers Google :

   ```bash
   ping -c 4 google.com
   ping -i 2 google.com
   ping -s 1000 google.com
   ```

2. Analysez le chemin des paquets :

   ```bash
   traceroute google.com
   traceroute -n google.com
   traceroute -m 15 google.com
   ```

3. Testez un **traceroute continu** avec MTR :

   ```bash
   mtr google.com
   mtr -r -c 10 google.com
   ```

   Interprétez les colonnes **Loss %**, **Snt**, **Last**, **Avg**.

4. Identifiez l’adresse IP de Google sans DNS :

   ```bash
   nslookup google.com 8.8.8.8
   dig google.com +short
   dig google.com MX
   host google.com
   ```

---

# [BLEU] **EXERCICE 3 — Connexions réseau et sockets**

## **Énoncé détaillé**

1. Listez les ports ouverts et les connexions actives :

   ```bash
   ss -tuln
   ss -tunap
   ss -s
   sudo lsof -i
   sudo lsof -i :22
   ```

2. Comparez avec `netstat` :

   ```bash
   netstat -tuln
   netstat -tunap
   netstat -i
   netstat -s
   ```

3. Filtrez les sockets par protocole ou utilisateur :

   ```bash
   ss sport = :80
   ss dst 192.168.1.100
   sudo lsof -u username
   sudo lsof -c sshd
   ```

4. Expérimentez l’observation des sockets en temps réel et notez les différences entre `ss` et `lsof`.

---

# [BLEU] **EXERCICE 4 — Transferts et tests de téléchargement**

## **Énoncé détaillé**

1. Téléchargez des fichiers avec `wget` :

   ```bash
   wget https://example.com/file.txt
   wget -O custom_name.txt https://example.com/file.txt
   wget -c https://example.com/largefile.zip
   wget -b https://example.com/file.txt
   ```

2. Testez des téléchargements récursifs ou limités :

   ```bash
   wget -r https://example.com/
   wget --limit-rate=200k https://example.com/file.zip
   wget -i urls.txt
   ```

3. Téléchargez avec `curl` :

   ```bash
   curl -O https://example.com/file.txt
   curl -o myfile.txt https://example.com/file.txt
   curl -I https://example.com
   curl -L https://example.com
   curl -d "key=value" -X POST https://example.com/api
   curl -s -v https://example.com
   ```

4. Comparez la vitesse et la facilité d’utilisation de `wget` vs `curl`.

---

# [BLEU] **EXERCICE 5 — Firewall, SSH et analyse réseau**

## **Énoncé détaillé**

1. **Firewall** :

   * Vérifiez l’état du firewall :

     ```bash
     sudo ufw status
     sudo iptables -L -v
     ```
   * Ajoutez, supprimez et testez des règles :

     ```bash
     sudo ufw allow 80/tcp
     sudo ufw deny 23
     sudo ufw delete allow 80
     sudo ufw reset
     sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
     sudo iptables -D INPUT 1
     ```

2. **SSH** :

   * Connectez-vous à un serveur local ou distant :

     ```bash
     ssh user@host
     ssh -p 2222 user@host
     ssh -i ~/.ssh/id_rsa user@host
     ```
   * Copiez des fichiers avec `scp` et `rsync` :

     ```bash
     scp file.txt user@host:/tmp/
     rsync -avz file.txt user@host:/tmp/
     ```

3. **Clés SSH** :

   * Générez une clé SSH et copiez-la sur un serveur :

     ```bash
     ssh-keygen -t ed25519 -C "email@example.com"
     ssh-copy-id user@host
     ```

4. **Analyse réseau** :

   * Capturez et analysez les paquets avec `tcpdump` :

     ```bash
     sudo tcpdump -i eth0 -c 50
     sudo tcpdump port 80
     sudo tcpdump -w capture.pcap
     sudo tcpdump -r capture.pcap
     ```
   * Scannez un hôte avec `nmap` :

     ```bash
     nmap 192.168.1.100
     nmap -p 1-1000 -sV 192.168.1.100
     nmap -O 192.168.1.100
     ```

5. **Tests de connectivité et bande passante** :

   * Créez un serveur et un client `nc` (netcat) pour tester la communication sur un port local :

     ```bash
     nc -l 1234
     nc localhost 1234
     ```
   * Testez la bande passante avec `iperf` :

     ```bash
     iperf -s
     iperf -c server_ip
     ```

---


[OK] DISQUES & SYSTÈMES DE FICHIERS

# === ESPACE DISQUE ===

# df - disk free
df                              # Espace disque
df -h                           # Human readable
df -T                           # Avec type filesystem
df -i                           # Inodes
df -t ext4                      # Seulement type spécifique
df /path                        # Pour point de montage spécifique

# du - disk usage
du                              # Usage répertoire courant
du -h                           # Human readable
du -s                           # Summary (total seulement)
du -sh *                        # Total par élément
du -sh dir/                     # Total d'un répertoire
du -h --max-depth=1             # Profondeur 1
du -h --max-depth=1 | sort -hr  # Trié par taille
du -ah                          # Inclure fichiers
du -c dir1/ dir2/               # Total cumulé

# Trouver gros fichiers/dossiers
du -ah /path | sort -rh | head -20
du -h --max-depth=1 / 2>/dev/null | sort -rh | head -10

# ncdu - du interactif (nécessite installation)
ncdu /path

# === MONTAGE FILESYSTEMS ===

# mount - monter filesystem
mount                           # Lister montages
mount | column -t               # Formaté
sudo mount /dev/sdb1 /mnt
sudo mount -t ext4 /dev/sdb1 /mnt
sudo mount -o ro /dev/sdb1 /mnt # Read-only
sudo mount -o remount,rw /mnt   # Remonter en read-write

# umount - démonter
sudo umount /mnt
sudo umount /dev/sdb1
sudo umount -f /mnt             # Force
sudo umount -l /mnt             # Lazy (démonte dès que possible)

# /etc/fstab - montages automatiques
# Format: device mountpoint fstype options dump pass
# /dev/sdb1 /data ext4 defaults 0 2
# UUID=xxx /data ext4 defaults 0 2

# Tester fstab
sudo mount -a                   # Monte tous ceux du fstab

# findmnt - arbre de montage
findmnt
findmnt /path
findmnt -t ext4                 # Par type

# === PARTITIONNEMENT ===

# fdisk - gestion partitions (MBR)
sudo fdisk -l                   # Lister disques
sudo fdisk /dev/sdb             # Éditer partitions
# Commandes dans fdisk:
# m: aide
# p: print
# n: nouvelle partition
# d: delete partition
# t: changer type
# w: write changes
# q: quit sans sauver

# parted - gestion partitions (GPT et MBR)
sudo parted -l                  # Lister
sudo parted /dev/sdb
# (parted) print
# (parted) mklabel gpt
# (parted) mkpart primary ext4 0% 100%
# (parted) quit

# gdisk - pour GPT
sudo gdisk -l /dev/sdb
sudo gdisk /dev/sdb

# lsblk - vue d'ensemble
lsblk
lsblk -f                        # Avec filesystems

# blkid - UUID et info
sudo blkid
sudo blkid /dev/sdb1

# === CRÉER FILESYSTEMS ===

# mkfs - créer filesystem
sudo mkfs.ext4 /dev/sdb1
sudo mkfs.xfs /dev/sdb1
sudo mkfs.btrfs /dev/sdb1
sudo mkfs -t ext4 /dev/sdb1     # Alternative

# Options ext4
sudo mkfs.ext4 -L mylabel /dev/sdb1     # Avec label
sudo mkfs.ext4 -m 1 /dev/sdb1           # 1% reserved blocks
sudo mkfs.ext4 -j /dev/sdb1             # Avec journal

# === VÉRIFIER & RÉPARER ===

# fsck - filesystem check
sudo fsck /dev/sdb1
sudo fsck -y /dev/sdb1          # Réparer automatiquement
sudo fsck -n /dev/sdb1          # Dry run
sudo fsck -C /dev/sdb1          # Progress bar

# IMPORTANT: démonter avant fsck!
sudo umount /dev/sdb1
sudo fsck /dev/sdb1

# e2fsck - pour ext2/3/4
sudo e2fsck /dev/sdb1
sudo e2fsck -f /dev/sdb1        # Force check
sudo e2fsck -p /dev/sdb1        # Automatic repair

# === SWAP ===

# Créer swap
sudo mkswap /dev/sdb2
sudo swapon /dev/sdb2
sudo swapon -s                  # Afficher swap actif

# Désactiver swap
sudo swapoff /dev/sdb2
sudo swapoff -a                 # Tous

# Fichier swap
sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# /etc/fstab pour swap permanent
# /swapfile none swap sw 0 0

# === LVM (Logical Volume Manager) ===

# Physical Volumes
sudo pvcreate /dev/sdb1
sudo pvdisplay
sudo pvs

# Volume Groups
sudo vgcreate vg_data /dev/sdb1
sudo vgdisplay
sudo vgs
sudo vgextend vg_data /dev/sdc1

# Logical Volumes
sudo lvcreate -L 10G -n lv_data vg_data
sudo lvcreate -l 100%FREE -n lv_data vg_data
sudo lvdisplay
sudo lvs

# Étendre LV
sudo lvextend -L +5G /dev/vg_data/lv_data
sudo lvextend -l +100%FREE /dev/vg_data/lv_data
sudo resize2fs /dev/vg_data/lv_data  # Resize filesystem

# === RAID ===

# mdadm - gérer RAID logiciel
sudo mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sdb1 /dev/sdc1
sudo mdadm --detail /dev/md0
cat /proc/mdstat
sudo mdadm --stop /dev/md0
sudo mdadm --assemble /dev/md0 /dev/sdb1 /dev/sdc1

# === QUOTAS DISQUE ===

# Activer quotas
# Ajouter usrquota,grpquota dans /etc/fstab
sudo mount -o remount /
sudo quotacheck -cugm /
sudo quotaon /

# Définir quotas
sudo edquota -u username
sudo setquota -u username 100000 110000 0 0 /

# Vérifier quotas
quota
quota -u username
sudo repquota -a


Voici **5 grands énoncés d’exercices détaillés** pour la section **Disques & systèmes de fichiers**, adaptés à une **installation Linux fraîche**, couvrant toutes les sous-sections avec des instructions concrètes étape par étape.

---

# [BLEU] **EXERCICE 1 — Exploration de l’espace disque et usage des fichiers**

## **Énoncé détaillé**

1. Vérifiez l’espace disque total et libre sur votre système :

   ```bash
   df -h
   df -T
   df -i
   ```

2. Analysez l’espace utilisé dans votre répertoire personnel :

   ```bash
   du -sh ~
   du -sh * 
   du -h --max-depth=1 | sort -hr
   ```

3. Trouvez les **20 plus gros fichiers et dossiers** dans `/home` :

   ```bash
   du -ah /home 2>/dev/null | sort -rh | head -20
   ```

4. Installez et utilisez `ncdu` pour naviguer de manière interactive dans l’espace disque :

   ```bash
   sudo apt install ncdu      # ou yum install ncdu
   ncdu /home
   ```

5. Comparez les résultats de `du` et `ncdu` et notez les différences dans l’affichage.

---

# [BLEU] **EXERCICE 2 — Montage et démontage de fichiers systèmes**

## **Énoncé détaillé**

1. Listez tous les montages actuels :

   ```bash
   mount | column -t
   findmnt
   ```

2. Montez une partition disponible en lecture-écriture et en lecture seule :

   ```bash
   sudo mount -t ext4 /dev/sdb1 /mnt
   sudo mount -o ro /dev/sdb1 /mnt
   sudo mount -o remount,rw /mnt
   ```

3. Démontez la partition avec différentes méthodes :

   ```bash
   sudo umount /mnt
   sudo umount -f /mnt
   sudo umount -l /mnt
   ```

4. Configurez un montage automatique dans `/etc/fstab` et testez-le :

   ```bash
   sudo nano /etc/fstab
   sudo mount -a
   ```

5. Vérifiez que le montage fonctionne correctement avec `findmnt /mnt`.

---

# [BLEU] **EXERCICE 3 — Partitionnement et création de fichiers systèmes**

## **Énoncé détaillé**

1. Listez les disques et partitions disponibles :

   ```bash
   lsblk
   sudo fdisk -l
   sudo parted -l
   ```

2. Créez une nouvelle partition sur un disque non utilisé avec `fdisk` ou `parted` :

   ```bash
   sudo fdisk /dev/sdb
   # Commandes: n, p, w
   sudo parted /dev/sdb
   # Commandes: mklabel gpt, mkpart primary ext4 0% 100%, quit
   ```

3. Créez un **filesystem ext4** sur cette partition :

   ```bash
   sudo mkfs.ext4 -L data /dev/sdb1
   sudo mkfs.ext4 -m 1 -j /dev/sdb1
   ```

4. Vérifiez le filesystem avec `fsck` ou `e2fsck` :

   ```bash
   sudo umount /dev/sdb1
   sudo fsck -n /dev/sdb1
   sudo fsck -y /dev/sdb1
   ```

5. Montez la partition et créez des fichiers pour tester l’accès en lecture/écriture.

---

# [BLEU] **EXERCICE 4 — Swap et gestion de volumes logiques (LVM)**

## **Énoncé détaillé**

1. Créez un fichier swap de 2 Go et activez-le :

   ```bash
   sudo fallocate -l 2G /swapfile
   sudo chmod 600 /swapfile
   sudo mkswap /swapfile
   sudo swapon /swapfile
   swapon -s
   ```

2. Désactivez le swap :

   ```bash
   sudo swapoff /swapfile
   sudo swapoff -a
   ```

3. Créez un **Physical Volume (PV)**, un **Volume Group (VG)** et un **Logical Volume (LV)** :

   ```bash
   sudo pvcreate /dev/sdb1
   sudo vgcreate vg_data /dev/sdb1
   sudo lvcreate -L 5G -n lv_data vg_data
   sudo lvdisplay
   ```

4. Formatez le LV et montez-le :

   ```bash
   sudo mkfs.ext4 /dev/vg_data/lv_data
   sudo mount /dev/vg_data/lv_data /mnt
   ```

5. Étendez le LV et le filesystem pour utiliser tout l’espace libre :

   ```bash
   sudo lvextend -l +100%FREE /dev/vg_data/lv_data
   sudo resize2fs /dev/vg_data/lv_data
   ```

---

# [BLEU] **EXERCICE 5 — RAID logiciel et quotas disque**

## **Énoncé détaillé**

1. Créez un **RAID 1** avec deux partitions :

   ```bash
   sudo mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sdb1 /dev/sdc1
   sudo mdadm --detail /dev/md0
   cat /proc/mdstat
   ```

2. Arrêtez et réassemblez le RAID :

   ```bash
   sudo mdadm --stop /dev/md0
   sudo mdadm --assemble /dev/md0 /dev/sdb1 /dev/sdc1
   ```

3. Activez les quotas sur `/home` et configurez-les pour un utilisateur :

   ```bash
   sudo mount -o remount /home
   sudo quotacheck -cugm /home
   sudo quotaon /home
   sudo edquota -u username
   sudo setquota -u username 100000 110000 0 0 /
   quota -u username
   ```

4. Vérifiez et interprétez les quotas avec `repquota -a`.

5. Simulez un dépassement de quota en créant des fichiers dans `/home` et observez le comportement du système.

---



[OK] GESTION UTILISATEURS & GROUPES

# === UTILISATEURS ===

# Créer utilisateur
sudo useradd username
sudo useradd -m username        # Avec home directory
sudo useradd -m -s /bin/bash username
sudo useradd -m -d /custom/home username
sudo useradd -m -G sudo,docker username  # Avec groupes
sudo useradd -m -e 2024-12-31 username   # Date expiration

# adduser - interactif (Debian/Ubuntu)
sudo adduser username

# Modifier utilisateur
sudo usermod -l newname oldname # Renommer
sudo usermod -d /new/home username
sudo usermod -s /bin/zsh username
sudo usermod -L username        # Lock account
sudo usermod -U username        # Unlock account
sudo usermod -aG groupname username  # Ajouter à groupe
sudo usermod -g groupname username   # Changer groupe primaire

# Supprimer utilisateur
sudo userdel username
sudo userdel -r username        # Avec home directory
sudo userdel -f username        # Force

# Mot de passe
sudo passwd username
passwd                          # Changer son propre mot de passe
sudo passwd -l username         # Lock
sudo passwd -u username         # Unlock
sudo passwd -e username         # Forcer changement au prochain login
sudo passwd -d username         # Supprimer mot de passe
sudo passwd -S username         # Status

# Changer shell
chsh
chsh -s /bin/zsh

# Info utilisateurs
id                              # Info user courant
id username
whoami
who                             # Qui est connecté
w                               # Qui fait quoi
users                           # Liste users connectés
last                            # Historique connexions
lastlog                         # Dernière connexion par user

# Fichiers utilisateurs
cat /etc/passwd                 # Liste utilisateurs
cat /etc/shadow                 # Mots de passe (root seulement)
cat /etc/group                  # Groupes

# === GROUPES ===

# Créer groupe
sudo groupadd groupname
sudo groupadd -g 1050 groupname # Avec GID spécifique

# Modifier groupe
sudo groupmod -n newname oldname
sudo groupmod -g 1050 groupname

# Supprimer groupe
sudo groupdel groupname

# Ajouter user à groupe
sudo gpasswd -a username groupname
sudo usermod -aG groupname username

# Retirer user de groupe
sudo gpasswd -d username groupname

# Lister groupes d'un user
groups username
id -nG username

# Lister membres d'un groupe
getent group groupname
grep groupname /etc/group

# === SUDO & PERMISSIONS ===

# Utiliser sudo
sudo command
sudo -u username command        # En tant qu'autre user
sudo -i                         # Shell root interactif
sudo -s                         # Shell avec environnement user
sudo su                         # Devenir root
sudo su - username              # Devenir autre user
sudo !!                         # Répéter dernière commande avec sudo

# Configuration sudo (/etc/sudoers)
sudo visudo                     # Éditer sudoers (safe)

# Syntaxe sudoers:
# username ALL=(ALL:ALL) ALL
# %groupname ALL=(ALL:ALL) ALL
# username ALL=(ALL) NOPASSWD: ALL
# username ALL=(ALL) /bin/systemctl restart nginx

# Tester config sudo
sudo -l                         # Ce que user peut faire
sudo -ll                        # Détaillé

# === SU - SWITCH USER ===

su                              # Devenir root
su -                            # Devenir root avec environnement
su username                     # Devenir autre user
su - username                   # Avec environnement
exit                            # Revenir à user précédent


Voici **4 grands énoncés d’exercices complets**, parfaitement adaptés à un système Linux **tout juste installé**, donc avec **peu d’utilisateurs, peu de groupes et très peu de données**.

Chaque exercice couvre **toute la section** :
[OK] création/modification/suppression d’utilisateurs
[OK] gestion des groupes
[OK] sudo & sudoers
[OK] changement de shell
[OK] inspection des fichiers système (/etc/passwd, /etc/group…)
[OK] commandes su / sudo
[OK] verrouillage comptes, expiration, ajout au groupe, etc.

---

# [BLEU] **EXERCICE 1 — Créer et gérer une petite équipe d’utilisateurs**

## **Énoncé**

Après une installation fraîche de Linux, vous devez préparer le système pour accueillir **trois nouveaux utilisateurs** :

* `alice` (doit pouvoir utiliser sudo)
* `bob` (pas de sudo)
* `charlie` (compte expirant dans 30 jours)

Vous devez réaliser les actions suivantes :

### - Création des comptes

1. Crée les 3 utilisateurs, chacun avec un **home directory**.

2. Donne un **shell différent** à chaque utilisateur :

   * alice -> bash
   * bob -> zsh
   * charlie -> bash

3. Définis un mot de passe pour chaque utilisateur.

### - Gestion avancée

4. Ajoute *alice* au groupe **sudo**.
5. Verrouille temporairement le compte *bob*.
6. Définis une **date d’expiration** pour *charlie* 30 jours à partir d’aujourd’hui.
7. Renomme *charlie* en `charlie_dev`.

### - Vérification

8. Affiche toutes les informations système sur chaque utilisateur (id, groupes…).
9. Vérifie dans `/etc/passwd`, `/etc/group` et `/etc/shadow` que tout est correct.
10. Affiche la liste des utilisateurs connectés.

---

# [BLEU] **EXERCICE 2 — Gestion des groupes et permissions sudo**

## **Énoncé**

Votre système doit maintenant organiser les utilisateurs en **groupes fonctionnels**.
Vous devez créer :

* un groupe `dev`
* un groupe `ops`

### - Manipulation des groupes

1. Crée les deux groupes.

2. Ajoute les utilisateurs suivants :

   * alice -> `dev`
   * bob -> `dev`
   * charlie_dev -> `ops`

3. Change le **groupe primaire** de bob pour `dev`.

4. Liste :

   * les groupes de chaque utilisateur
   * les membres de chaque groupe

### - Sudo & sudoers

5. Configure via `visudo` :

   * alice peut faire **tout** avec sudo.
   * bob peut uniquement exécuter `systemctl restart ssh`.
   * charlie_dev ne peut utiliser sudo **pour aucune commande**.

6. Vérifie la configuration sudo pour chaque utilisateur (`sudo -l`).

### - Nettoyage

7. Retire bob du groupe `dev`.
8. Supprime le groupe `ops`.
9. Montre que charlie_dev n’a plus de groupe `ops`.

---

# [BLEU] **EXERCICE 3 — Simulation de changement d’utilisateur & administration**

## **Énoncé**

Tu dois simuler une petite opération d’administration dans laquelle tu navigues entre les comptes, vérifies les accès et verrouilles/déverrouilles des comptes.

### - Passage utilisateur -> root -> utilisateur

1. Connecte-toi en tant que bob avec `su - bob`.

2. Depuis bob, ouvre une session root via :

   * `su -`
   * puis via `sudo -i`
     (tester les deux approches).

3. Reviens à l'utilisateur précédent avec `exit`.

### - Restrictions d’accès

4. Tente d’exécuter une commande réservée à root (ex : `apt update`) depuis bob et note le résultat.
5. Déverrouille le compte bob s’il avait été verrouillé.
6. Forcer bob à changer de mot de passe à la prochaine connexion.

### - Audit & logs

7. Utilise :

   * `who`
   * `users`
   * `w`
   * `last`
   * `lastlog`

   pour analyser les sessions du système.

8. Explique ce que représente chaque fichier :

   * `/etc/passwd`
   * `/etc/group`
   * `/etc/shadow`

9. Trouve tous les utilisateurs système (UID < 1000).

---

# [BLEU] **EXERCICE 4 — Création / suppression / configuration d’un environnement utilisateur complet**

## **Énoncé**

Tu dois créer un utilisateur “test” que tu utiliseras pour simuler un cycle de vie complet : création -> modification -> verrouillage -> suppression.

### - Création

1. Crée l’utilisateur `testuser` avec :

   * un home directory
   * le shell `/bin/bash`
   * le groupe primaire `testgroup` (à créer)
   * un mot de passe

2. Ajoute `testuser` aux groupes :

   * sudo
   * docker  (si non existant, crée-le)

### - Modification

3. Change son shell vers `/bin/zsh`.
4. Change son home vers `/home/tuser`.
5. Renomme l’utilisateur `testuser` -> `produser`.

### - Verrouillage & restrictions

6. Verrouille le compte.
7. Déverrouille-le.
8. Supprime le mot de passe de l’utilisateur.
9. Force le mot de passe à être modifié au prochain login.

### - Suppression

10. Supprime l’utilisateur **avec son home directory**.
11. Supprime les groupes créés (`testgroup`, `docker` si créé).
12. Vérifie que le compte a totalement disparu de :

* `/etc/passwd`
* `/etc/group`
* `/etc/shadow`

---


[OK] SERVICES & SYSTEMD

# === SYSTEMD (système init moderne) ===

# Gérer services
sudo systemctl start service
sudo systemctl stop service
sudo systemctl restart service
sudo systemctl reload service   # Recharger config sans restart
sudo systemctl status service
sudo systemctl enable service   # Démarrage automatique
sudo systemctl disable service
sudo systemctl is-active service
sudo systemctl is-enabled service

# Lister services
systemctl list-units --type=service
systemctl list-units --type=service --state=running
systemctl list-units --type=service --state=failed
systemctl --failed

# Lister tous les unit files
systemctl list-unit-files
systemctl list-unit-files --type=service

# Logs de service
sudo journalctl -u service
sudo journalctl -u service -f   # Follow
sudo journalctl -u service --since today
sudo journalctl -u service --since "2024-01-01"
sudo journalctl -u service --since "1 hour ago"

# Recharger systemd
sudo systemctl daemon-reload

# Targets (runlevels)
systemctl get-default
sudo systemctl set-default multi-user.target
systemctl list-units --type=target

# Système
sudo systemctl reboot
sudo systemctl poweroff
sudo systemctl suspend
sudo systemctl hibernate

# === JOURNALCTL - LOGS SYSTEMD ===

# Voir tous les logs
sudo journalctl

# Filtres temps
sudo journalctl --since "2024-01-01"
sudo journalctl --since yesterday
sudo journalctl --since "1 hour ago"
sudo journalctl --until "2024-01-02"
sudo journalctl --since "10:00" --until "11:00"

# Par boot
sudo journalctl -b              # Boot actuel
sudo journalctl -b -1           # Boot précédent
sudo journalctl --list-boots

# Par priorité
sudo journalctl -p err          # Erreurs seulement
sudo journalctl -p warning      # Warning et plus grave

# Par service/unit
sudo journalctl -u nginx.service
sudo journalctl -u nginx.service -u mysql.service

# Follow
sudo journalctl -f
sudo journalctl -u service -f

# Par processus
sudo journalctl _PID=1234

# Format
sudo journalctl -o json         # JSON
sudo journalctl -o json-pretty
sudo journalctl -o verbose

# Limiter lignes
sudo journalctl -n 50           # 50 dernières lignes
sudo journalctl --no-pager

# Espace disque des logs
sudo journalctl --disk-usage
sudo journalctl --vacuum-time=2weeks
sudo journalctl --vacuum-size=500M

# === SYSTEMCTL AVANCÉ ===

# Créer service custom (/etc/systemd/system/myapp.service)
# [Unit]
# Description=My Application
# After=network.target
#
# [Service]
# Type=simple
# User=myuser
# WorkingDirectory=/opt/myapp
# ExecStart=/usr/bin/python3 /opt/myapp/app.py
# Restart=always
#
# [Install]
# WantedBy=multi-user.target

# Activer et démarrer
sudo systemctl daemon-reload
sudo systemctl enable myapp.service
sudo systemctl start myapp.service

# Éditer service
sudo systemctl edit service     # Override file
sudo systemctl edit --full service  # Éditer file complet

# Dépendances
systemctl list-dependencies service
systemctl list-dependencies --reverse service

# === ANCIENS SYSTÈMES (SYSVINIT) ===

# service command (marche avec systemd aussi)
sudo service nginx start
sudo service nginx stop
sudo service nginx restart
sudo service nginx status

# chkconfig (RHEL/CentOS ancien)
sudo chkconfig nginx on
sudo chkconfig nginx off
sudo chkconfig --list

# update-rc.d (Debian/Ubuntu ancien)
sudo update-rc.d nginx defaults
sudo update-rc.d nginx enable
sudo update-rc.d nginx disable


Voici **5 grands énoncés d’exercices détaillés** pour la section **Services & systemd**, adaptés à une installation Linux fraîche, couvrant tous les aspects de la gestion des services et des logs.

---

# [BLEU] **EXERCICE 1 — Découverte et contrôle des services avec systemd**

## **Énoncé détaillé**

1. Listez tous les services sur le système :

   ```bash
   systemctl list-units --type=service
   systemctl list-unit-files --type=service
   ```

2. Identifiez les services **en cours d’exécution** et ceux **en échec** :

   ```bash
   systemctl list-units --type=service --state=running
   systemctl --failed
   ```

3. Choisissez un service existant (ex : `cron`, `ssh` ou `nginx` si installé) et :

   * Vérifiez son statut
   * Démarrez-le / arrêtez-le
   * Redémarrez-le
   * Activez-le pour le démarrage automatique

   ```bash
   sudo systemctl status cron
   sudo systemctl stop cron
   sudo systemctl start cron
   sudo systemctl restart cron
   sudo systemctl enable cron
   sudo systemctl disable cron
   ```

4. Testez la commande `is-active` et `is-enabled` pour votre service choisi.

5. Notez la différence entre les commandes `systemctl` et l’ancienne commande `service` pour le même service.

---

# [BLEU] **EXERCICE 2 — Analyse des logs avec journalctl**

## **Énoncé détaillé**

1. Affichez les **logs récents du système** :

   ```bash
   sudo journalctl -n 50
   sudo journalctl --no-pager
   ```

2. Filtrez les logs par temps :

   ```bash
   sudo journalctl --since "1 hour ago"
   sudo journalctl --since yesterday --until today
   ```

3. Filtrez les logs par **service** choisi (`cron`, `ssh`…) :

   ```bash
   sudo journalctl -u cron.service
   sudo journalctl -u cron.service -f
   ```

4. Filtrez par **priorité** : uniquement les erreurs et warnings :

   ```bash
   sudo journalctl -p err
   sudo journalctl -p warning
   ```

5. Vérifiez l’espace disque utilisé par les logs et effectuez une **purge automatique** si nécessaire :

   ```bash
   sudo journalctl --disk-usage
   sudo journalctl --vacuum-time=1week
   sudo journalctl --vacuum-size=100M
   ```

---

# [BLEU] **EXERCICE 3 — Gestion des targets et redémarrage du système**

## **Énoncé détaillé**

1. Vérifiez le **target par défaut** :

   ```bash
   systemctl get-default
   ```

2. Changez le target pour **multi-user.target** et redémarrez :

   ```bash
   sudo systemctl set-default multi-user.target
   sudo systemctl reboot
   ```

3. Listez tous les targets disponibles et identifiez ceux utilisés pour le démarrage graphique :

   ```bash
   systemctl list-units --type=target
   ```

4. Testez les commandes de gestion système : suspend, hibernate et poweroff (selon support matériel) :

   ```bash
   sudo systemctl suspend
   sudo systemctl hibernate
   sudo systemctl poweroff
   ```

5. Notez le comportement du système et la différence entre ces commandes.

---

# [BLEU] **EXERCICE 4 — Création et gestion d’un service custom**

## **Énoncé détaillé**

1. Créez un répertoire `/opt/myapp` et un petit script Python ou Bash :

   ```bash
   mkdir -p /opt/myapp
   echo -e '#!/bin/bash\necho "Mon service custom fonctionne"\nsleep 60' > /opt/myapp/app.sh
   chmod +x /opt/myapp/app.sh
   ```

2. Créez un fichier `myapp.service` dans `/etc/systemd/system/` :

   ```ini
   [Unit]
   Description=Mon Service Custom
   After=network.target

   [Service]
   Type=simple
   ExecStart=/opt/myapp/app.sh
   Restart=always

   [Install]
   WantedBy=multi-user.target
   ```

3. Rechargez systemd et démarrez le service :

   ```bash
   sudo systemctl daemon-reload
   sudo systemctl start myapp.service
   sudo systemctl enable myapp.service
   sudo systemctl status myapp.service
   ```

4. Modifiez le service avec `systemctl edit` et testez les changements.

5. Observez le journal du service :

   ```bash
   sudo journalctl -u myapp.service -f
   ```

---

# [BLEU] **EXERCICE 5 — Dépendances et introspection avancée**

## **Énoncé détaillé**

1. Listez toutes les dépendances d’un service système (ex : `ssh`) :

   ```bash
   systemctl list-dependencies ssh
   systemctl list-dependencies --reverse ssh
   ```

2. Identifiez les services sur lesquels dépend votre service custom créé précédemment.

3. Redémarrez `systemd` pour prendre en compte de nouveaux services ou modifications :

   ```bash
   sudo systemctl daemon-reload
   ```

4. Comparez les informations avec les anciennes commandes SysVinit (`service`, `update-rc.d`) :

   ```bash
   sudo service ssh status
   sudo update-rc.d ssh defaults
   ```

5. Notez les différences entre systemd et SysVinit en termes de **démarrage automatique, logs et gestion des dépendances**.

---



[OK] GESTION PAQUETS

# === DEBIAN/UBUNTU (APT) ===

# Mettre à jour liste paquets
sudo apt update

# Mettre à jour paquets installés
sudo apt upgrade
sudo apt full-upgrade           # Peut supprimer paquets

# Installer
sudo apt install package
sudo apt install package1 package2
sudo apt install package=version

# Supprimer
sudo apt remove package
sudo apt purge package          # Avec fichiers config
sudo apt autoremove             # Supprimer dépendances inutiles

# Rechercher
apt search keyword
apt-cache search keyword

# Info paquet
apt show package
apt-cache show package
apt-cache policy package        # Versions disponibles

# Lister paquets
apt list --installed
apt list --upgradable
dpkg -l                         # Tous paquets
dpkg -l | grep package

# Fichiers d'un paquet
dpkg -L package                 # Lister fichiers
dpkg -S /path/to/file           # Quel paquet contient ce fichier

# Nettoyer
sudo apt clean                  # Cache complet
sudo apt autoclean              # Vieux paquets seulement
sudo apt autoremove

# Fichiers .deb
sudo dpkg -i package.deb
sudo dpkg -r package
sudo dpkg --configure -a        # Réparer installations cassées
sudo apt --fix-broken install

# Sources (/etc/apt/sources.list)
sudo add-apt-repository ppa:user/repo
sudo add-apt-repository --remove ppa:user/repo

# === REDHAT/CENTOS/FEDORA (YUM/DNF) ===

# DNF (Fedora, RHEL 8+, CentOS 8+)
sudo dnf update                 # Mettre à jour
sudo dnf install package
sudo dnf remove package
sudo dnf search keyword
sudo dnf info package
sudo dnf list installed
sudo dnf list available
sudo dnf provides /path/to/file # Quel paquet fournit ce fichier
sudo dnf clean all
sudo dnf autoremove
sudo dnf upgrade                # Upgrade système

# YUM (RHEL/CentOS 7 et antérieur)
sudo yum update
sudo yum install package
sudo yum remove package
sudo yum search keyword
sudo yum info package
sudo yum list installed
sudo yum provides /path/to/file
sudo yum clean all

# RPM - gestion paquets bas niveau
sudo rpm -ivh package.rpm       # Installer
sudo rpm -Uvh package.rpm       # Upgrade
sudo rpm -e package             # Supprimer
rpm -qa                         # Lister tous paquets
rpm -qa | grep package          # Rechercher
rpm -ql package                 # Fichiers du paquet
rpm -qf /path/to/file           # Quel paquet contient ce fichier
rpm -qi package                 # Info paquet

# Repos
sudo yum repolist
sudo dnf repolist
sudo yum-config-manager --add-repo URL
sudo dnf config-manager --add-repo URL

# === ARCH LINUX (PACMAN) ===

# Mettre à jour système
sudo pacman -Syu

# Installer
sudo pacman -S package
sudo pacman -S package1 package2

# Supprimer
sudo pacman -R package
sudo pacman -Rs package         # Avec dépendances
sudo pacman -Rns package        # Avec dépendances et config

# Rechercher
pacman -Ss keyword
pacman -Qs keyword              # Dans paquets installés

# Info
pacman -Si package              # Repo
pacman -Qi package              # Installé

# Lister
pacman -Q                       # Tous installés
pacman -Qe                      # Explicitement installés
pacman -Qdt                     # Orphelins

# Fichiers
pacman -Ql package              # Lister fichiers
pacman -Qo /path/to/file        # Quel paquet contient

# Nettoyer cache
sudo pacman -Sc
sudo pacman -Scc                # Tout le cache

# AUR (Arch User Repository)
# Utiliser un AUR helper comme yay ou paru
yay -S package
yay -Syu                        # Mettre à jour tout (AUR inclus)

# === OPENSUSE (ZYPPER) ===

sudo zypper refresh             # Mettre à jour repos
sudo zypper update
sudo zypper install package
sudo zypper remove package
sudo zypper search keyword
sudo zypper info package
sudo zypper list-updates
sudo zypper clean

# === SNAP (UBUNTU ET AUTRES) ===

snap find package
sudo snap install package
sudo snap install package --classic
sudo snap remove package
snap list
sudo snap refresh               # Mettre à jour tous
sudo snap refresh package       # Mettre à jour un paquet
snap info package

# === FLATPAK ===

flatpak search package
flatpak install flathub package
flatpak uninstall package
flatpak list
flatpak update
flatpak run com.example.App

# Ajouter Flathub
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

# === APPIMAGE ===

chmod +x app.AppImage
./app.AppImage

# === COMPILATION DEPUIS SOURCE ===

# Méthode classique (GNU Autotools)
./configure
make
sudo make install
sudo make uninstall             # Si disponible

# Avec préfixe personnalisé
./configure --prefix=/opt/myapp
make
sudo make install

# CMake
mkdir build && cd build
cmake ..
make
sudo make install

# Vérifier dépendances avant compilation
./configure --help              # Options disponibles
sudo apt install build-essential  # Outils compilation Debian/Ubuntu
sudo yum groupinstall "Development Tools"  # RHEL/CentOS


Voici **5 grands énoncés d’exercices détaillés** pour la section **Gestion des paquets**, adaptés à une installation Linux fraîche et simple, sans beaucoup de fichiers ni d’utilisateurs.

---

# [BLEU] **EXERCICE 1 — Découverte et mise à jour des paquets**

## **Énoncé détaillé**

1. Vérifiez que votre liste de paquets est à jour :

   ```bash
   sudo apt update
   sudo apt list --upgradable
   ```

2. Mettez à jour tous les paquets installés (sans supprimer de paquets) :

   ```bash
   sudo apt upgrade
   ```

3. Effectuez une mise à jour complète du système et notez les différences avec `upgrade` :

   ```bash
   sudo apt full-upgrade
   ```

4. Lister tous les paquets installés et repérez quelques paquets connus (`bash`, `coreutils`) :

   ```bash
   apt list --installed
   dpkg -l | grep bash
   ```

5. Comparez avec les commandes équivalentes sur un système Fedora ou CentOS si disponible (`dnf update`, `dnf list installed`).

---

# [BLEU] **EXERCICE 2 — Installation et suppression de paquets**

## **Énoncé détaillé**

1. Installez un paquet simple, par exemple `htop` :

   ```bash
   sudo apt install htop
   ```

2. Installez plusieurs paquets en même temps, et installez une version spécifique si possible :

   ```bash
   sudo apt install htop=2.2.0-1 nano
   ```

3. Supprimez un paquet et observez la différence entre `remove` et `purge` :

   ```bash
   sudo apt remove htop
   sudo apt purge nano
   ```

4. Supprimez les dépendances inutiles :

   ```bash
   sudo apt autoremove
   ```

5. Testez l’installation d’un paquet à partir d’un fichier `.deb` téléchargé :

   ```bash
   sudo dpkg -i package.deb
   sudo apt --fix-broken install  # Corriger les dépendances si nécessaire
   ```

---

# [BLEU] **EXERCICE 3 — Recherche et informations sur les paquets**

## **Énoncé détaillé**

1. Recherchez des paquets par mot-clé :

   ```bash
   apt search editor
   apt-cache search editor
   ```

2. Affichez les informations détaillées d’un paquet (`nano` ou `htop`) :

   ```bash
   apt show nano
   apt-cache show nano
   apt-cache policy nano
   ```

3. Listez tous les fichiers installés par un paquet et identifiez à quel paquet appartient un fichier :

   ```bash
   dpkg -L nano
   dpkg -S /usr/bin/nano
   ```

4. Vérifiez les paquets orphelins ou inutilisés et notez leur utilité pour le nettoyage.

5. Comparez les commandes équivalentes sur Fedora/CentOS avec `dnf info`, `dnf provides`.

---

# [BLEU] **EXERCICE 4 — Gestion des sources et paquets alternatifs**

## **Énoncé détaillé**

1. Affichez votre liste de dépôts actuels :

   ```bash
   cat /etc/apt/sources.list
   ls /etc/apt/sources.list.d/
   ```

2. Ajoutez un dépôt PPA et installez un paquet depuis ce dépôt :

   ```bash
   sudo add-apt-repository ppa:deadsnakes/ppa
   sudo apt update
   sudo apt install python3.11
   ```

3. Supprimez le PPA et observez les différences :

   ```bash
   sudo add-apt-repository --remove ppa:deadsnakes/ppa
   sudo apt update
   ```

4. Installez un paquet via **Snap** et observez les différences avec apt :

   ```bash
   sudo snap install hello-world
   snap list
   ```

5. Installez un paquet via **Flatpak**, si disponible, et comparez :

   ```bash
   flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
   flatpak install flathub org.gimp.GIMP
   flatpak list
   ```

---

# [BLEU] **EXERCICE 5 — Compilation et gestion avancée de paquets**

## **Énoncé détaillé**

1. Installez les outils de compilation nécessaires sur Debian/Ubuntu :

   ```bash
   sudo apt install build-essential
   ```

2. Téléchargez une source simple et compilez-la :

   ```bash
   wget http://ftp.gnu.org/gnu/hello/hello-2.12.tar.gz
   tar xvf hello-2.12.tar.gz
   cd hello-2.12
   ./configure
   make
   sudo make install
   ```

3. Compilez avec un **préfixe personnalisé** et notez où les fichiers sont installés :

   ```bash
   ./configure --prefix=/opt/hello
   make
   sudo make install
   ```

4. Utilisez CMake pour un projet simple et comparez les étapes avec `./configure && make`.

5. Nettoyez le cache des paquets installés et observez la différence entre `apt clean`, `apt autoclean` et `apt autoremove` :

   ```bash
   sudo apt clean
   sudo apt autoclean
   sudo apt autoremove
   ```

---



[OK] VARIABLES D'ENVIRONNEMENT & SHELL

# === VARIABLES ===

# Afficher variable
echo $HOME
echo $PATH
echo $USER
echo $SHELL

# Définir variable (session actuelle)
VAR="value"
export VAR="value"              # Disponible pour sous-processus

# Variables importantes:
# $HOME: répertoire home
# $USER: nom utilisateur
# $PATH: chemins exécutables
# $SHELL: shell par défaut
# $PWD: répertoire courant
# $OLDPWD: répertoire précédent
# $LANG: langue système
# $TERM: type terminal

# Afficher toutes variables
printenv
env
set                             # Inclut variables shell

# Afficher PATH lisiblement
echo $PATH | tr ':' '\n'

# Modifier PATH
export PATH=$PATH:/new/path
export PATH=/new/path:$PATH     # Au début

# Définir permanent (ajouter à ~/.bashrc ou ~/.zshrc)
export VAR="value"
export PATH=$PATH:/my/custom/path

# Supprimer variable
unset VAR

# Variables spéciales shell:
# $0: nom du script
# $1, $2, etc.: arguments
# $#: nombre d'arguments
# $@: tous les arguments
# $?: code retour dernière commande
# $: PID du shell
# $!: PID dernier processus background

# === ALIAS ===

# Définir alias
alias ll='ls -lah'
alias la='ls -A'
alias ..='cd ..'
alias ...='cd ../..'
alias grep='grep --color=auto'
alias update='sudo apt update && sudo apt upgrade'

# Lister alias
alias

# Supprimer alias
unalias ll

# Alias permanent (ajouter à ~/.bashrc ou ~/.zshrc)
# Éditer fichier et ajouter vos alias

# Recharger config
source ~/.bashrc
source ~/.zshrc

# === CONFIGURATION SHELL ===

# Fichiers de configuration Bash:
# /etc/profile: système (tous users)
# /etc/bash.bashrc: système Bash
# ~/.bash_profile: user (login shell)
# ~/.bashrc: user (interactive shell)
# ~/.bash_logout: exécuté à la déconnexion

# Fichiers de configuration Zsh:
# /etc/zsh/zshrc: système
# ~/.zshrc: user

# Éditer configuration
nano ~/.bashrc
nano ~/.zshrc

# Recharger après modification
source ~/.bashrc

# === HISTORIQUE COMMANDES ===

# Afficher historique
history
history 20                      # 20 dernières commandes

# Rechercher dans historique
history | grep keyword
Ctrl+R                          # Recherche interactive

# Exécuter depuis historique
!123                            # Commande numéro 123
!!                              # Dernière commande
!$                              # Dernier argument dernière commande
!*                              # Tous arguments dernière commande
!ssh                            # Dernière commande commençant par ssh

# Configurer historique (~/.bashrc)
export HISTSIZE=10000           # Nombre en mémoire
export HISTFILESIZE=20000       # Nombre dans fichier
export HISTCONTROL=ignoredups   # Ignorer doublons
export HISTIGNORE="ls:cd:pwd"   # Ignorer commandes

# Nettoyer historique
history -c                      # Effacer session
rm ~/.bash_history              # Effacer fichier

# === SCRIPTS SHELL ===

# Créer script
nano script.sh

# Shebang (première ligne)
#!/bin/bash
#!/usr/bin/env bash             # Plus portable

# Exemple script:
#!/bin/bash
echo "Hello World"
VAR="test"
echo "Variable: $VAR"

# Rendre exécutable
chmod +x script.sh

# Exécuter
./script.sh
bash script.sh

# Arguments
# $0: nom script
# $1, $2: arguments
echo "Script: $0"
echo "Argument 1: $1"
echo "Nombre d'arguments: $#"

# Conditions
if [ "$VAR" = "value" ]; then
    echo "Match"
elif [ "$VAR" = "other" ]; then
    echo "Other"
else
    echo "No match"
fi

# Tests courants:
# -f file: fichier existe
# -d dir: répertoire existe
# -r file: readable
# -w file: writable
# -x file: executable
# -z "$var": variable vide
# -n "$var": variable non vide
# "$a" = "$b": égalité strings
# "$a" != "$b": différence strings
# $a -eq $b: égalité nombres
# $a -ne $b: différence nombres
# $a -gt $b: plus grand
# $a -lt $b: plus petit

# Boucles
for i in 1 2 3 4 5; do
    echo $i
done

for file in *.txt; do
    echo "Processing $file"
done

while [ condition ]; do
    echo "Running"
    sleep 1
done

# Fonctions
function myfunction() {
    echo "Argument: $1"
    return 0
}

myfunction "test"

# === REDIRECTIONS ===

# Sortie standard (stdout)
command > file                  # Écraser
command >> file                 # Ajouter
command 1> file                 # Explicite

# Erreur standard (stderr)
command 2> error.log
command 2>> error.log

# Les deux
command > output.log 2>&1
command &> output.log           # Raccourci Bash
command > output.log 2> error.log

# Entrée standard (stdin)
command < input.txt

# Here document
cat << EOF > file.txt
Line 1
Line 2
EOF

# Here string
command <<< "string"

# Supprimer sortie
command > /dev/null             # Stdout
command 2> /dev/null            # Stderr
command &> /dev/null            # Tout

# Tee - afficher et sauver
command | tee output.txt
command | tee -a output.txt     # Append

# === PIPES ===

# Pipe basique
command1 | command2
command1 | command2 | command3

# Exemples utiles
ls -l | grep ".txt"
cat file.txt | wc -l
ps aux | grep nginx
dmesg | tail -20
history | grep ssh
find . -type f | wc -l

# xargs - construire commandes depuis stdin
find . -name "*.log" | xargs rm
ls *.txt | xargs -I {} mv {} /dest/
echo "file1 file2 file3" | xargs -n 1 echo

# === OPÉRATEURS ===

# Exécution séquentielle
command1 ; command2             # Toujours exécuter command2

# Exécution conditionnelle
command1 && command2            # command2 si command1 réussit
command1 || command2            # command2 si command1 échoue

# Exemples
mkdir dir && cd dir
cd /path || exit 1
make && make install || echo "Failed"

# Background
command &                       # Exécuter en arrière-plan
command1 & command2 &           # Plusieurs en parallèle

# Grouper commandes
(command1; command2)            # Sous-shell
{ command1; command2; }         # Shell actuel

# === EXPANSION ===

# Brace expansion
echo {1..10}                    # 1 2 3 4 5 6 7 8 9 10
echo {a..z}                     # a b c ... z
echo file{1,2,3}.txt            # file1.txt file2.txt file3.txt
mkdir -p dir/{sub1,sub2,sub3}

# Tilde expansion
~                               # Home directory
~/Documents
~username

# Parameter expansion
${VAR}                          # Valeur de VAR
${VAR:-default}                 # default si VAR vide/unset
${VAR:=default}                 # Assigne default si vide
${VAR:?error message}           # Erreur si vide
${#VAR}                         # Longueur
${VAR#pattern}                  # Supprime pattern début (court)
${VAR##pattern}                 # Supprime pattern début (long)
${VAR%pattern}                  # Supprime pattern fin (court)
${VAR%%pattern}                 # Supprime pattern fin (long)
${VAR/pattern/replacement}      # Remplace première occurrence
${VAR//pattern/replacement}     # Remplace toutes occurrences

# Command substitution
$(command)                      # Résultat de command
`command`                       # Ancien style
VAR=$(ls -l)

# Arithmetic expansion
$((expression))
echo $((5 + 3))                 # 8
echo $((10 * 2))                # 20
i=$((i + 1))                    # Incrémenter


Voici **5 grands énoncés d’exercices détaillés** pour la section **Variables d’environnement & Shell**, adaptés à une installation Linux récente avec peu de fichiers et d’utilisateurs :

---

# [BLEU] **EXERCICE 1 — Exploration des variables et alias**

## **Énoncé détaillé**

1. Affichez les variables d’environnement importantes :

   ```bash
   echo $HOME
   echo $USER
   echo $SHELL
   echo $PATH
   ```

2. Listez toutes les variables disponibles et identifiez celles liées au terminal et à la langue :

   ```bash
   printenv
   env
   set
   ```

3. Créez une nouvelle variable `MYVAR` avec une valeur temporaire et exportez-la pour qu’elle soit disponible aux sous-processus :

   ```bash
   MYVAR="Hello"
   export MYVAR
   echo $MYVAR
   ```

4. Modifiez temporairement votre `PATH` pour inclure un dossier fictif `/opt/mybin` et vérifiez l’ordre des chemins :

   ```bash
   export PATH=$PATH:/opt/mybin
   echo $PATH | tr ':' '\n'
   ```

5. Créez un alias simple et testez-le, puis supprimez-le :

   ```bash
   alias ll='ls -lah'
   ll
   unalias ll
   ```

---

# [BLEU] **EXERCICE 2 — Gestion des fichiers de configuration du shell**

## **Énoncé détaillé**

1. Identifiez les fichiers de configuration pour Bash et Zsh :

   ```bash
   ls -la ~ | grep bash
   ls -la ~ | grep zsh
   ```

2. Ajoutez une variable permanente à votre `.bashrc` ou `.zshrc` :

   ```bash
   echo 'export MYPERM="Permanent"' >> ~/.bashrc
   source ~/.bashrc
   echo $MYPERM
   ```

3. Ajoutez un alias permanent et rechargez la configuration :

   ```bash
   echo "alias gs='git status'" >> ~/.bashrc
   source ~/.bashrc
   gs
   ```

4. Testez la modification temporaire de `PATH` dans votre shell et observez que les changements disparaissent à la fermeture du terminal.

5. Supprimez les ajouts faits à votre fichier `.bashrc` pour revenir à l’état initial.

---

# [BLEU] **EXERCICE 3 — Historique et commandes passées**

## **Énoncé détaillé**

1. Affichez l’historique des dernières commandes et filtrez celles contenant `ls` ou `nano` :

   ```bash
   history 20
   history | grep ls
   ```

2. Ré-exécutez la dernière commande et le dernier argument d’une commande précédente :

   ```bash
   !!
   !$
   ```

3. Configurez les options de votre historique pour ignorer certaines commandes répétitives :

   ```bash
   export HISTCONTROL=ignoredups
   export HISTIGNORE="ls:cd:pwd"
   ```

4. Effacez votre historique actuel et le fichier associé :

   ```bash
   history -c
   rm ~/.bash_history
   ```

5. Testez la recherche interactive avec `Ctrl+R` pour retrouver une commande précédente.

---

# [BLEU] **EXERCICE 4 — Création et exécution de scripts shell**

## **Énoncé détaillé**

1. Créez un script `test.sh` avec un shebang et une variable simple, puis rendez-le exécutable :

   ```bash
   nano test.sh
   #!/bin/bash
   VAR="Hello Script"
   echo "Message: $VAR"
   chmod +x test.sh
   ./test.sh
   ```

2. Ajoutez des arguments au script et affichez-les :

   ```bash
   ./test.sh arg1 arg2
   echo "Arg1: $1, Arg2: $2, Total: $#"
   ```

3. Implémentez une condition simple dans le script pour tester la valeur d’une variable :

   ```bash
   if [ "$VAR" = "Hello Script" ]; then
       echo "Condition OK"
   else
       echo "Condition FAIL"
   fi
   ```

4. Ajoutez une boucle `for` pour parcourir les fichiers `.txt` d’un répertoire et affichez leurs noms.

5. Définissez une fonction simple dans le script qui prend un argument et l’affiche, puis exécutez-la.

---

# [BLEU] **EXERCICE 5 — Redirections, pipes et expansions**

## **Énoncé détaillé**

1. Redirigez la sortie d’une commande vers un fichier et ajoutez-y des données :

   ```bash
   echo "Line 1" > output.txt
   echo "Line 2" >> output.txt
   cat output.txt
   ```

2. Redirigez la sortie d’erreur vers un fichier et combinez stdout et stderr :

   ```bash
   ls /nonexistent 2> error.log
   ls /nonexistent &> combined.log
   ```

3. Testez un pipe simple et un pipe avec plusieurs commandes :

   ```bash
   ls -l | grep ".sh" | wc -l
   ```

4. Utilisez `xargs` pour renommer ou supprimer des fichiers :

   ```bash
   echo "file1 file2 file3" | xargs -n 1 touch
   ls *.txt | xargs -I {} mv {} /tmp/
   ```

5. Expérimentez avec des expansions :

   ```bash
   echo {1..5}
   echo file{a,b,c}.txt
   VAR="Hello"
   echo ${VAR:-Default}
   echo ${VAR/Hello/Hi}
   echo $((5 + 3))
   ```

---



[OK] CRON & TÂCHES PLANIFIÉES

# === CRON ===

# Éditer crontab utilisateur
crontab -e

# Lister crontab
crontab -l

# Supprimer crontab
crontab -r

# Crontab d'un autre user (root)
sudo crontab -u username -e
sudo crontab -u username -l

# Format crontab:
# * * * * * command
# │ │ │ │ │
# │ │ │ │ └─── Jour de semaine (0-7, 0 et 7 = dimanche)
# │ │ │ └───── Mois (1-12)
# │ │ └─────── Jour du mois (1-31)
# │ └───────── Heure (0-23)
# └─────────── Minute (0-59)

# Exemples:
# Tous les jours à 2h30
30 2 * * * /path/to/script.sh

# Toutes les heures
0 * * * * command

# Toutes les 5 minutes
*/5 * * * * command

# Tous les lundis à 9h
0 9 * * 1 command

# Premier jour du mois à minuit
0 0 1 * * command

# Du lundi au vendredi à 18h
0 18 * * 1-5 command

# Plusieurs fois
0 8,12,18 * * * command         # 8h, 12h et 18h

# Variables dans crontab
SHELL=/bin/bash
PATH=/usr/local/bin:/usr/bin:/bin
MAILTO=user@example.com
HOME=/home/user

0 2 * * * /backup.sh

# Redirection sortie
0 2 * * * /script.sh > /tmp/output.log 2>&1
0 2 * * * /script.sh >> /tmp/output.log 2>&1

# Cron système (/etc/crontab)
# Format: minute heure jour mois jour_semaine user command
0 2 * * * root /backup.sh

# Répertoires cron (Debian/Ubuntu)
# /etc/cron.daily/     # Quotidien
# /etc/cron.hourly/    # Toutes les heures
# /etc/cron.weekly/    # Hebdomadaire
# /etc/cron.monthly/   # Mensuel

# Ajouter script dans ces dossiers (sans extension!)
sudo nano /etc/cron.daily/backup
sudo chmod +x /etc/cron.daily/backup

# Service cron
sudo systemctl status cron      # Debian/Ubuntu
sudo systemctl status crond     # RHEL/CentOS
sudo systemctl restart cron

# Logs cron
sudo grep CRON /var/log/syslog  # Debian/Ubuntu
sudo tail -f /var/log/cron      # RHEL/CentOS
sudo journalctl -u cron

# === AT - TÂCHE UNIQUE ===

# Planifier tâche
at 10:00
at> /path/to/script.sh
at> Ctrl+D

at now + 5 minutes
at 2:30 PM tomorrow
at 10:00 AM 2024-12-25

# Lister tâches
atq
at -l

# Voir détails
at -c job_number

# Supprimer tâche
atrm job_number
at -r job_number

# Depuis fichier
at -f script.sh now + 1 hour

# Service at
sudo systemctl status atd
sudo systemctl start atd

# === SYSTEMD TIMERS ===

# Alternative moderne à cron
# Créer timer (/etc/systemd/system/mytask.timer)
# [Unit]
# Description=My Task Timer
#
# [Timer]
# OnCalendar=daily
# Persistent=true
#
# [Install]
# WantedBy=timers.target

# Créer service (/etc/systemd/system/mytask.service)
# [Unit]
# Description=My Task
#
# [Service]
# Type=oneshot
# ExecStart=/path/to/script.sh

# Activer
sudo systemctl daemon-reload
sudo systemctl enable mytask.timer
sudo systemctl start mytask.timer

# Voir timers
systemctl list-timers
systemctl list-timers --all

# OnCalendar exemples:
# hourly, daily, weekly, monthly, yearly
# *-*-* 02:30:00          # Quotidien à 2h30
# Mon *-*-* 09:00:00      # Lundis à 9h
# *-*-01 00:00:00         # Premier du mois


Voici **5 grands énoncés d’exercices détaillés** pour la section **Cron & tâches planifiées**, adaptés à une installation Linux récente avec peu de fichiers et d’utilisateurs :

---

# [BLEU] **EXERCICE 1 — Planification simple avec cron utilisateur**

## **Énoncé détaillé**

1. Créez un script simple `hello.sh` dans votre répertoire personnel qui affiche `Hello Cron` et la date :

   ```bash
   #!/bin/bash
   echo "Hello Cron: $(date)"
   ```

   Rendez-le exécutable :

   ```bash
   chmod +x ~/hello.sh
   ```

2. Planifiez ce script avec `crontab -e` pour qu’il s’exécute toutes les 5 minutes et redirige la sortie vers `/tmp/hello.log`.

3. Listez vos crontabs avec `crontab -l` et vérifiez que la ligne a été ajoutée.

4. Attendez ou modifiez le minuteur pour tester le script et vérifiez la sortie :

   ```bash
   cat /tmp/hello.log
   ```

5. Supprimez la crontab pour nettoyer l’environnement :

   ```bash
   crontab -r
   ```

---

# [BLEU] **EXERCICE 2 — Crontab système et scripts périodiques**

## **Énoncé détaillé**

1. Créez un script `backup_dummy` dans `/etc/cron.daily/` qui écrit la date et `Backup dummy run` dans `/tmp/backup.log` :

   ```bash
   sudo nano /etc/cron.daily/backup_dummy
   sudo chmod +x /etc/cron.daily/backup_dummy
   ```

2. Vérifiez que le script est exécutable par root.

3. Redémarrez le service cron et forcez l’exécution pour tester :

   ```bash
   sudo systemctl restart cron
   sudo run-parts /etc/cron.daily/
   ```

4. Vérifiez le log `/tmp/backup.log`.

5. Explorez les autres dossiers `/etc/cron.hourly/`, `/etc/cron.weekly/` et `/etc/cron.monthly/` pour comprendre l’organisation des tâches périodiques.

---

# [BLEU] **EXERCICE 3 — Planification unique avec `at`**

## **Énoncé détaillé**

1. Créez un script `at_test.sh` qui écrit `Task executed by at` et la date dans `/tmp/at.log`.

2. Planifiez son exécution 5 minutes plus tard :

   ```bash
   at now + 5 minutes
   at> ~/at_test.sh
   at> Ctrl+D
   ```

3. Vérifiez la liste des tâches planifiées avec `atq`.

4. Consultez le contenu de la tâche planifiée :

   ```bash
   at -c job_number
   ```

5. Supprimez la tâche planifiée avant qu’elle ne s’exécute :

   ```bash
   atrm job_number
   ```

---

# [BLEU] **EXERCICE 4 — Redirections et logs cron/at**

## **Énoncé détaillé**

1. Modifiez un script cron ou `at` pour rediriger la sortie standard et les erreurs vers un fichier spécifique, par exemple `/tmp/test.log` :

   ```bash
   echo "Test cron output" > /tmp/test.log 2>&1
   ```

2. Planifiez son exécution et observez le fichier log après exécution.

3. Analysez les logs du service cron :

   ```bash
   sudo grep CRON /var/log/syslog
   sudo journalctl -u cron
   ```

4. Pour `at`, vérifiez la sortie en inspectant le log ou fichier généré par le script.

5. Testez la suppression de sorties inutiles en redirigeant vers `/dev/null`.

---

# [BLEU] **EXERCICE 5 — Utilisation de systemd timers**

## **Énoncé détaillé**

1. Créez un script `timer_test.sh` qui écrit `Timer executed` et la date dans `/tmp/timer.log`.

2. Créez un service systemd `/etc/systemd/system/timer_test.service` :

   ```ini
   [Unit]
   Description=Test Timer Service

   [Service]
   Type=oneshot
   ExecStart=/home/user/timer_test.sh
   ```

3. Créez le timer `/etc/systemd/system/timer_test.timer` pour exécution quotidienne à 2h30 :

   ```ini
   [Unit]
   Description=Daily Timer Test

   [Timer]
   OnCalendar=*-*-* 02:30:00
   Persistent=true

   [Install]
   WantedBy=timers.target
   ```

4. Rechargez systemd, activez et démarrez le timer :

   ```bash
   sudo systemctl daemon-reload
   sudo systemctl enable timer_test.timer
   sudo systemctl start timer_test.timer
   ```

5. Vérifiez les timers actifs et leurs dernières exécutions :

   ```bash
   systemctl list-timers --all
   cat /tmp/timer.log
   ```

---



[OK] LOGS & DEBUGGING

# === FICHIERS LOGS PRINCIPAUX ===

# Debian/Ubuntu
/var/log/syslog                 # Logs système généraux
/var/log/auth.log               # Authentification
/var/log/kern.log               # Kernel
/var/log/boot.log               # Boot
/var/log/dmesg                  # Messages kernel boot
/var/log/apt/                   # APT logs

# RHEL/CentOS
/var/log/messages               # Système général
/var/log/secure                 # Authentification
/var/log/maillog                # Mail
/var/log/cron                   # Cron
/var/log/yum.log                # YUM

# Communs
/var/log/nginx/                 # Nginx
/var/log/apache2/               # Apache
/var/log/mysql/                 # MySQL
/var/log/postgresql/            # PostgreSQL

# === CONSULTER LOGS ===

# Logs système traditionnels
sudo tail -f /var/log/syslog
sudo tail -100 /var/log/auth.log
sudo less /var/log/syslog
sudo cat /var/log/syslog | grep error

# dmesg - messages kernel
dmesg
dmesg | tail
dmesg | grep -i usb
dmesg -w                        # Watch mode
dmesg -T                        # Timestamps lisibles
dmesg -l err,warn               # Erreurs et warnings

# journalctl (déjà couvert dans section SYSTEMD)
sudo journalctl -xe             # Détails récents
sudo journalctl --since today
sudo journalctl -p err
sudo journalctl -u service.service

# === LOGROTATE ===

# Configuration: /etc/logrotate.conf et /etc/logrotate.d/

# Exemple config (/etc/logrotate.d/myapp)
# /var/log/myapp/*.log {
#     daily
#     rotate 7
#     compress
#     delaycompress
#     missingok
#     notifempty
#     create 0640 www-data www-data
#     sharedscripts
#     postrotate
#         systemctl reload myapp
#     endscript
# }

# Tester config
sudo logrotate -d /etc/logrotate.conf

# Forcer rotation
sudo logrotate -f /etc/logrotate.conf

# === RSYSLOG ===

# Config principale: /etc/rsyslog.conf
# Config supplémentaire: /etc/rsyslog.d/

# Exemple règle:
# facility.priority    destination
# *.info               /var/log/info.log
# auth,authpriv.*      /var/log/auth.log
# mail.*               /var/log/mail.log

# Redémarrer rsyslog
sudo systemctl restart rsyslog

# Tester envoi log
logger "Test message"
logger -p user.err "Error message"

# === DEBUGGING SCRIPTS ===

# Activer debug mode
bash -x script.sh
set -x                          # Dans le script
set +x                          # Désactiver

# Options utiles
set -e                          # Arrêter sur erreur
set -u                          # Erreur sur variable undefined
set -o pipefail                 # Erreur dans pipe

# Combiné (début de script)
set -euo pipefail

# Tracer exécution
bash -v script.sh               # Verbose

# === STRACE - TRACER APPELS SYSTÈME ===

# Tracer programme
strace command
strace -o output.txt command
strace -p PID                   # Attacher à processus existant

# Filtrer appels
strace -e open command          # Seulement open
strace -e trace=file command    # Opérations fichiers
strace -e trace=network command # Opérations réseau

# Statistiques
strace -c command

# === LTRACE - TRACER APPELS BIBLIOTHÈQUE ===

ltrace command
ltrace -o output.txt command
ltrace -p PID

# === PERFORMANCE ===

# time - mesurer temps exécution
time command
time -p command                 # Format POSIX

# perf - profiling performance
sudo perf top                   # Top temps réel
sudo perf stat command          # Statistiques
sudo perf record command        # Enregistrer
sudo perf report                # Voir rapport

# === DEBUGGING RÉSEAU ===

# netstat/ss (déjà couvert)
# tcpdump (déjà couvert)

# curl verbose
curl -v URL
curl -I URL                     # Headers seulement

# Test DNS
nslookup domain
dig domain
host domain

# Test port
telnet host port
nc -zv host port


Voici **5 grands énoncés d’exercices détaillés** pour la section **Logs & Debugging**, adaptés à un Linux neuf avec peu de fichiers et d’utilisateurs :

---

# [BLEU] **EXERCICE 1 — Exploration des fichiers logs système**

## **Énoncé détaillé**

1. Listez tous les fichiers de log disponibles sur votre système (`/var/log/`) et notez leurs types (syslog, auth, kern, boot…).

2. Affichez les 50 dernières lignes du fichier `/var/log/syslog` (ou `/var/log/messages` sur RHEL/CentOS) avec `tail`.

3. Recherchez toutes les occurrences de `error` dans `/var/log/syslog` avec `grep`.

4. Utilisez `less` pour parcourir `/var/log/auth.log` et observez les tentatives de login.

5. Vérifiez les messages du kernel avec `dmesg` et testez `dmesg -T` pour obtenir des timestamps lisibles.

---

# [BLEU] **EXERCICE 2 — Création et test de logs personnalisés**

## **Énoncé détaillé**

1. Utilisez `logger` pour écrire des messages dans les logs système :

   ```bash
   logger "Mon premier message test"
   logger -p user.err "Message d'erreur test"
   ```

2. Vérifiez la présence de vos messages dans `/var/log/syslog` ou `/var/log/messages`.

3. Créez un petit script `log_test.sh` qui écrit des logs :

   ```bash
   #!/bin/bash
   echo "Script exécuté à $(date)" | logger -t log_test
   ```

   Rendez-le exécutable et lancez-le.

4. Recherchez les messages du script avec :

   ```bash
   grep log_test /var/log/syslog
   ```

5. Supprimez vos fichiers temporaires ou messages de test pour nettoyer l’environnement.

---

# [BLEU] **EXERCICE 3 — Rotation des logs avec logrotate**

## **Énoncé détaillé**

1. Créez un répertoire `/var/log/myapp` et un fichier de log `myapp.log` :

   ```bash
   sudo mkdir /var/log/myapp
   sudo touch /var/log/myapp/myapp.log
   ```

2. Écrivez une configuration logrotate dans `/etc/logrotate.d/myapp` pour :

   * Rotation quotidienne
   * Conserver 3 fichiers
   * Compresser les anciens
   * Créer les logs avec permissions `0640`

3. Testez la configuration en mode debug :

   ```bash
   sudo logrotate -d /etc/logrotate.conf
   ```

4. Forcez une rotation pour voir le résultat :

   ```bash
   sudo logrotate -f /etc/logrotate.conf
   ```

5. Vérifiez que les fichiers compressés sont bien créés dans `/var/log/myapp`.

---

# [BLEU] **EXERCICE 4 — Debugging de scripts bash**

## **Énoncé détaillé**

1. Créez un script `debug_test.sh` avec une erreur volontaire :

   ```bash
   #!/bin/bash
   set -euo pipefail
   echo "Début du script"
   echo $UNDEFINED_VAR
   echo "Fin du script"
   ```

2. Exécutez-le avec `bash -x debug_test.sh` pour suivre chaque commande.

3. Modifiez le script pour activer/désactiver le debug avec `set -x` et `set +x`.

4. Testez l’arrêt automatique sur erreur avec `set -e`.

5. Corrigez l’erreur et observez la différence d’exécution.

---

# [BLEU] **EXERCICE 5 — Tracer les appels système et mesurer performance**

## **Énoncé détaillé**

1. Choisissez une commande simple, par exemple `ls -l`, et tracez ses appels système :

   ```bash
   strace -o strace_output.txt ls -l
   ```

2. Filtrez uniquement les opérations fichiers :

   ```bash
   strace -e trace=file ls -l
   ```

3. Utilisez `ltrace` pour tracer les appels aux bibliothèques de la même commande :

   ```bash
   ltrace -o ltrace_output.txt ls -l
   ```

4. Mesurez le temps d’exécution avec `time ls -l`.

5. (Optionnel) Installez `perf` et testez :

   ```bash
   sudo perf stat ls -l
   sudo perf top
   ```

---



[OK] ARCHIVAGE & BACKUP

# === RSYNC - SYNCHRONISATION ===

# Synchronisation basique
rsync -av source/ dest/
rsync -av /source/ user@host:/dest/

# Options importantes:
# -a: archive mode (récursif, préserve attributs)
# -v: verbose
# -z: compression
# -h: human readable
# -P: progress + partial
# --delete: supprime dans dest si absent de source
# --exclude: exclure patterns
# --dry-run: simulation

# Exemples pratiques
rsync -avz source/ dest/
rsync -avzP source/ user@host:/dest/
rsync -av --delete source/ dest/
rsync -av --exclude='*.log' --exclude='node_modules' source/ dest/
rsync -av --dry-run source/ dest/

# Backup avec hard links (économise espace)
rsync -av --link-dest=/backup/previous /source/ /backup/current/

# Via SSH avec port custom
rsync -av -e "ssh -p 2222" source/ user@host:/dest/

# Limiter bande passante
rsync -av --bwlimit=1000 source/ dest/  # 1000 KB/s

# === DD - COPIE BAS NIVEAU ===

# Copier disque/partition
sudo dd if=/dev/sda of=/dev/sdb bs=4M status=progress
sudo dd if=/dev/sda1 of=/backup/partition.img bs=4M

# Créer image ISO
sudo dd if=/dev/cdrom of=disc.iso bs=4M

# Créer USB bootable
sudo dd if=ubuntu.iso of=/dev/sdb bs=4M status=progress

# Effacer disque
sudo dd if=/dev/zero of=/dev/sdb bs=4M status=progress
sudo dd if=/dev/urandom of=/dev/sdb bs=4M  # Sécurisé

# Backup MBR
sudo dd if=/dev/sda of=mbr_backup.img bs=512 count=1

# Restaurer MBR
sudo dd if=mbr_backup.img of=/dev/sda bs=512 count=1

# === AUTRES OUTILS BACKUP ===

# duplicity - backup incrémental chiffré
duplicity /source file:///backup
duplicity --encrypt-key KEY /source sftp://user@host/backup

# borgbackup - backup dédupliqué
borg init --encryption=repokey /path/to/repo
borg create /path/to/repo::archive-name /source
borg list /path/to/repo
borg extract /path/to/repo::archive-name
borg prune --keep-daily=7 --keep-weekly=4 /path/to/repo

# restic - backup moderne
restic -r /backup init
restic -r /backup backup /source
restic -r /backup snapshots
restic -r /backup restore latest --target /restore

# === SCRIPTS BACKUP ===

# Exemple script backup avec tar
#!/bin/bash
BACKUP_DIR="/backup"
SOURCE="/data"
DATE=$(date +%Y%m%d_%H%M%S)
FILENAME="backup_${DATE}.tar.gz"

tar -czf "${BACKUP_DIR}/${FILENAME}" "${SOURCE}"

# Garder seulement 7 derniers backups
cd "${BACKUP_DIR}"
ls -t backup_*.tar.gz | tail -n +8 | xargs -r rm

# Exemple avec rotation
#!/bin/bash
BACKUP_DIR="/backup"
SOURCE="/data"
DATE=$(date +%Y-%m-%d)

# Backup incrémental avec rsync
rsync -av --link-dest="${BACKUP_DIR}/latest" \
    "${SOURCE}/" "${BACKUP_DIR}/${DATE}/"

# Mettre à jour lien "latest"
rm -f "${BACKUP_DIR}/latest"
ln -s "${DATE}" "${BACKUP_DIR}/latest"


Voici **5 grands énoncés d’exercices détaillés** pour la section **Archivage & Backup**, adaptés à un Linux neuf avec peu de fichiers et d’utilisateurs :

---

# [BLEU] **EXERCICE 1 — Synchronisation de répertoires avec rsync**

## **Énoncé détaillé**

1. Créez deux répertoires `source/` et `dest/` dans votre home.
2. Ajoutez quelques fichiers et sous-répertoires dans `source/`.
3. Synchronisez `source/` vers `dest/` en utilisant `rsync -av`.
4. Testez une synchronisation simulée avec `--dry-run` pour vérifier ce qui serait copié.
5. Ajoutez un fichier `.log` et un dossier `node_modules/` à `source/` et utilisez `--exclude` pour les ignorer lors de la synchronisation.
6. Supprimez un fichier dans `source/` et synchronisez avec `--delete` pour voir la suppression dans `dest/`.

---

# [BLEU] **EXERCICE 2 — Sauvegarde incrémentale et hard links**

## **Énoncé détaillé**

1. Créez un répertoire `/backup` et un sous-répertoire `previous/` avec quelques fichiers de test.
2. Utilisez `rsync -av --link-dest=/backup/previous source/ /backup/current/` pour créer une sauvegarde incrémentale.
3. Ajoutez/modifiez un fichier dans `source/` et recréez une nouvelle sauvegarde dans `/backup/new/`.
4. Vérifiez que les fichiers inchangés utilisent des hard links pour économiser de l’espace.
5. Comparez la taille des répertoires avant et après pour observer l’effet des hard links.

---

# [BLEU] **EXERCICE 3 — Sauvegarde et restauration avec dd**

## **Énoncé détaillé**

> Attention : pour cet exercice, utilisez de petits fichiers ou partitions virtuelles (ex : fichiers loopback) plutôt que des disques réels.

1. Créez un fichier image de 100 Mo pour simuler un disque :

   ```bash
   dd if=/dev/zero of=disk.img bs=1M count=100
   ```

2. Copiez des données dans ce fichier simulé (par ex. créez des fichiers avec `dd` ou `echo`).

3. Faites une sauvegarde du "disque" avec `dd if=disk.img of=disk_backup.img bs=4M`.

4. Modifiez le fichier d’origine, puis restaurez-le à partir de la sauvegarde.

5. Testez la création d’un ISO à partir d’un petit dossier avec `dd` et vérifiez son contenu avec `mount -o loop`.

---

# [BLEU] **EXERCICE 4 — Backup avec tar et rotation**

## **Énoncé détaillé**

1. Créez un répertoire `/data` avec plusieurs fichiers de test.

2. Écrivez un script `backup_tar.sh` qui :

   * Crée un fichier compressé `backup_YYYYMMDD_HHMMSS.tar.gz` dans `/backup`.
   * Conserve seulement les 3 derniers backups, supprimant les plus anciens.

3. Rendez le script exécutable et lancez-le plusieurs fois pour générer plusieurs archives.

4. Vérifiez que la rotation fonctionne correctement (seuls les 3 derniers fichiers restent).

5. Testez la restauration d’un backup en décompressant un `.tar.gz` dans un autre répertoire.

---

# [BLEU] **EXERCICE 5 — Automatisation avec rsync et backup incrémental**

## **Énoncé détaillé**

1. Créez un répertoire `/backup` et `/data` avec quelques fichiers.

2. Écrivez un script `backup_rsync.sh` qui :

   * Fait un backup incrémental de `/data` vers `/backup/YYYY-MM-DD/` en utilisant `rsync --link-dest`.
   * Met à jour un lien symbolique `latest` vers le dernier backup.

3. Testez le script plusieurs fois en ajoutant/modifiant des fichiers dans `/data`.

4. Vérifiez que le lien `latest` pointe toujours vers le dernier backup et que les fichiers inchangés utilisent des hard links.

5. (Optionnel) Ajoutez des options pour exclure certains fichiers ou dossiers (`--exclude`).

---



[OK] SÉCURITÉ

# === FIREWALL (déjà couvert en partie) ===

# Voir section RÉSEAU pour iptables, ufw, firewalld

# === FAIL2BAN ===

# Installer
sudo apt install fail2ban

# Configuration
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
sudo nano /etc/fail2ban/jail.local

# Exemple config SSH
# [sshd]
# enabled = true
# port = ssh
# filter = sshd
# logpath = /var/log/auth.log
# maxretry = 3
# bantime = 3600

# Gérer service
sudo systemctl status fail2ban
sudo systemctl restart fail2ban

# Commandes
sudo fail2ban-client status
sudo fail2ban-client status sshd
sudo fail2ban-client set sshd unbanip IP

# === SELINUX (RHEL/CENTOS) ===

# Statut SELinux
getenforce
sestatus

# Modes:
# Enforcing: appliqué
# Permissive: log seulement
# Disabled: désactivé

# Changer mode temporaire
sudo setenforce 0               # Permissive
sudo setenforce 1               # Enforcing

# Changer mode permanent (/etc/selinux/config)
# SELINUX=enforcing|permissive|disabled

# Contextes SELinux
ls -Z file
ps -eZ
id -Z

# Restaurer contextes
sudo restorecon -Rv /path/

# Changer contexte
sudo chcon -t httpd_sys_content_t /var/www/html/file

# Voir logs SELinux
sudo ausearch -m avc -ts recent
sudo grep AVC /var/log/audit/audit.log

# === APPARMOR (UBUNTU) ===

# Statut
sudo aa-status
sudo apparmor_status

# Modes profil:
# enforce: appliqué
# complain: log seulement

# Mettre profil en mode complain
sudo aa-complain /path/to/profile

# Mettre en mode enforce
sudo aa-enforce /path/to/profile

# Désactiver profil
sudo ln -s /etc/apparmor.d/profile /etc/apparmor.d/disable/
sudo apparmor_parser -R /etc/apparmor.d/profile

# Logs
sudo journalctl | grep apparmor
sudo dmesg | grep apparmor

# === CHIFFREMENT ===

# LUKS - chiffrement disque
sudo cryptsetup luksFormat /dev/sdb1
sudo cryptsetup luksOpen /dev/sdb1 encrypted_disk
sudo mkfs.ext4 /dev/mapper/encrypted_disk
sudo mount /dev/mapper/encrypted_disk /mnt

# Fermer volume chiffré
sudo umount /mnt
sudo cryptsetup luksClose encrypted_disk

# GPG - chiffrement fichiers
# Générer clé
gpg --full-generate-key

# Lister clés
gpg --list-keys
gpg --list-secret-keys

# Chiffrer fichier
gpg -e -r email@example.com file.txt
gpg --encrypt --recipient email@example.com file.txt

# Déchiffrer
gpg -d file.txt.gpg > file.txt
gpg --decrypt file.txt.gpg

# Signer fichier
gpg --sign file.txt

# Chiffrer symétrique (mot de passe)
gpg -c file.txt
gpg --symmetric file.txt

# === AUDIT SÉCURITÉ ===

# lynis - audit sécurité système
sudo lynis audit system

# chkrootkit - détecter rootkits
sudo chkrootkit

# rkhunter - détecter rootkits
sudo rkhunter --check

# ClamAV - antivirus
sudo apt install clamav
sudo freshclam                  # Mettre à jour signatures
sudo clamscan -r /path
sudo clamscan -r --infected /path

# === PERMISSIONS AVANCÉES ===

# Déjà couvert dans section PERMISSIONS
# Voir: chmod, chown, ACL, attributs

# === LIMITES RESSOURCES ===

# ulimit - limites shell
ulimit -a                       # Voir toutes limites
ulimit -n                       # Nombre fichiers ouverts
ulimit -n 4096                  # Définir limite
ulimit -u                       # Nombre processus
ulimit -m                       # Mémoire

# Limites système (/etc/security/limits.conf)
# username soft nofile 4096
# username hard nofile 8192
# @groupname soft nproc 100
# * soft core 0

# Voir limites d'un processus
cat /proc/PID/limits


Voici **5 grands énoncés d’exercices détaillés** pour la section **Sécurité**, adaptés à un Linux neuf et minimal :

---

# [BLEU] **EXERCICE 1 — Protéger SSH avec Fail2Ban**

## **Énoncé détaillé**

1. Installez `fail2ban` :

   ```bash
   sudo apt install fail2ban
   ```
2. Copiez la configuration par défaut et éditez le fichier local :

   ```bash
   sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
   sudo nano /etc/fail2ban/jail.local
   ```
3. Activez la protection SSH et configurez : `maxretry = 3`, `bantime = 600`.
4. Redémarrez le service et vérifiez le statut :

   ```bash
   sudo systemctl restart fail2ban
   sudo fail2ban-client status
   sudo fail2ban-client status sshd
   ```
5. Simulez plusieurs tentatives de connexion SSH échouées (ex. depuis un autre terminal) et observez si Fail2Ban bloque l’IP.
6. Débloquez l’IP avec `sudo fail2ban-client set sshd unbanip IP`.

---

# [BLEU] **EXERCICE 2 — SELinux : statut, mode et contexte**

## **Énoncé détaillé**

> Pour Ubuntu/Debian, SELinux peut être simulé avec un conteneur ou VM, sinon cet exercice est théorique.

1. Vérifiez le statut SELinux :

   ```bash
   getenforce
   sestatus
   ```
2. Changez temporairement le mode :

   ```bash
   sudo setenforce 0   # Permissive
   sudo setenforce 1   # Enforcing
   ```
3. Créez un fichier test `/tmp/testfile` et observez son contexte :

   ```bash
   ls -Z /tmp/testfile
   ```
4. Changez le contexte du fichier :

   ```bash
   sudo chcon -t httpd_sys_content_t /tmp/testfile
   ```
5. Utilisez `restorecon` pour restaurer le contexte par défaut et consultez les logs AVC :

   ```bash
   sudo restorecon -Rv /tmp/testfile
   sudo ausearch -m avc -ts recent
   ```

---

# [BLEU] **EXERCICE 3 — AppArmor : profil et logs**

## **Énoncé détaillé**

1. Vérifiez les profils actifs et leur mode :

   ```bash
   sudo aa-status
   sudo apparmor_status
   ```
2. Choisissez un petit programme (ex : `/usr/bin/less`) et mettez son profil en mode `complain` :

   ```bash
   sudo aa-complain /usr/bin/less
   ```
3. Revenez en mode `enforce` :

   ```bash
   sudo aa-enforce /usr/bin/less
   ```
4. Vérifiez les logs générés par AppArmor :

   ```bash
   sudo journalctl | grep apparmor
   sudo dmesg | grep apparmor
   ```
5. (Optionnel) Désactivez un profil et observez le comportement du programme.

---

# [BLEU] **EXERCICE 4 — Chiffrement de fichiers et volumes**

## **Énoncé détaillé**

1. **Chiffrement de fichier avec GPG** :

   * Créez un fichier `secret.txt` et chiffrez-le pour un utilisateur fictif :

     ```bash
     gpg -c secret.txt       # symétrique
     gpg -e -r email@example.com secret.txt  # asymétrique
     ```
   * Déchiffrez le fichier et vérifiez le contenu.
   * Signer le fichier avec GPG.

2. **Chiffrement de disque/partition avec LUKS** (utiliser un fichier loopback pour sécurité) :

   ```bash
   dd if=/dev/zero of=encrypted.img bs=1M count=50
   sudo cryptsetup luksFormat encrypted.img
   sudo cryptsetup luksOpen encrypted.img encrypted_disk
   sudo mkfs.ext4 /dev/mapper/encrypted_disk
   sudo mount /dev/mapper/encrypted_disk /mnt
   echo "Test" > /mnt/test.txt
   sudo umount /mnt
   sudo cryptsetup luksClose encrypted_disk
   ```

3. Montez et vérifiez que le fichier est accessible après déchiffrement.

---

# [BLEU] **EXERCICE 5 — Audit et limites système**

## **Énoncé détaillé**

1. Lancez un audit de sécurité avec Lynis :

   ```bash
   sudo lynis audit system
   ```
2. Vérifiez l’absence de rootkits avec `chkrootkit` et `rkhunter`.
3. Installez ClamAV et scannez un petit répertoire :

   ```bash
   sudo apt install clamav
   sudo freshclam
   sudo clamscan -r /home/user/test
   ```
4. Vérifiez et modifiez les limites de ressources du shell :

   ```bash
   ulimit -a
   ulimit -n 4096
   ulimit -u 100
   ```
5. Consultez les limites d’un processus courant via `/proc/PID/limits`.

---


[OK] PERFORMANCE & OPTIMISATION

# === ANALYSE PERFORMANCE ===

# top/htop (déjà couvert dans PROCESSUS)

# iotop - I/O par processus
sudo iotop
sudo iotop -o                   # Seulement processus actifs
sudo iotop -b -n 5              # Batch mode, 5 itérations

# iftop - bande passante réseau
sudo iftop
sudo iftop -i eth0              # Interface spécifique
sudo iftop -n                   # Sans résolution DNS

# nethogs - bande passante par processus
sudo nethogs
sudo nethogs eth0

# atop - monitoring complet
atop
atop 5                          # Intervalle 5 secondes
atop -r /var/log/atop/atop_20240101  # Lecture logs

# sysstat - collecte statistiques
# Installation: sudo apt install sysstat
sar -u 5 10                     # CPU, 5 sec, 10 fois
sar -r 5 10                     # Mémoire
sar -d 5 10                     # Disque
sar -n DEV 5 10                 # Réseau

# === TUNING SYSTÈME ===

# sysctl - paramètres kernel
sysctl -a                       # Tous paramètres
sysctl vm.swappiness            # Paramètre spécifique
sudo sysctl -w vm.swappiness=10 # Modifier temporaire

# Modifier permanent (/etc/sysctl.conf ou /etc/sysctl.d/)
# vm.swappiness = 10
# net.ipv4.ip_forward = 1
# fs.file-max = 65536

# Appliquer modifications
sudo sysctl -p

# Paramètres réseau utiles
# net.core.rmem_max = 134217728
# net.core.wmem_max = 134217728
# net.ipv4.tcp_rmem = 4096 87380 67108864
# net.ipv4.tcp_wmem = 4096 65536 67108864
# net.ipv4.tcp_congestion_control = bbr

# Paramètres filesystem
# fs.file-max = 2097152
# fs.inotify.max_user_watches = 524288

# === I/O SCHEDULER ===

# Voir scheduler actuel
cat /sys/block/sda/queue/scheduler

# Changer scheduler
echo deadline | sudo tee /sys/block/sda/queue/scheduler
echo cfq | sudo tee /sys/block/sda/queue/scheduler
echo noop | sudo tee /sys/block/sda/queue/scheduler

# Permanent (GRUB):
# Éditer /etc/default/grub
# GRUB_CMDLINE_LINUX_DEFAULT="... elevator=deadline"
# sudo update-grub

# === CACHE & BUFFERS ===

# Voir utilisation mémoire
free -h
cat /proc/meminfo

# Vider caches (généralement pas nécessaire!)
# Drop page cache
sudo sync; echo 1 | sudo tee /proc/sys/vm/drop_caches

# Drop dentries et inodes
sudo sync; echo 2 | sudo tee /proc/sys/vm/drop_caches

# Drop tout
sudo sync; echo 3 | sudo tee /proc/sys/vm/drop_caches

# === FILESYSTEM TUNING ===

# ext4 options de montage
# /etc/fstab:
# UUID=xxx / ext4 noatime,nodiratime,errors=remount-ro 0 1

# Options utiles:
# noatime: pas de mise à jour access time
# nodiratime: pas de mise à jour access time dirs
# relatime: mise à jour relative (défaut moderne)
# commit=60: commit changes toutes les 60 sec
# data=writeback: meilleur performance (moins safe)

# Tune2fs - modifier ext2/3/4
sudo tune2fs -l /dev/sda1       # Info filesystem
sudo tune2fs -m 1 /dev/sda1     # Reserved blocks 1%
sudo tune2fs -c 0 /dev/sda1     # Disable check count
sudo tune2fs -i 0 /dev/sda1     # Disable check interval

# XFS tuning
sudo xfs_info /dev/sda1

# === SWAP ===

# Swappiness (tendance à swapper)
cat /proc/sys/vm/swappiness
sudo sysctl vm.swappiness=10    # Moins de swap (SSD)

# Créer/gérer swap (déjà couvert dans DISQUES)

# === ANALYSE BOTTLENECKS ===

# CPU
# - top, htop: voir charge CPU
# - mpstat: stats par CPU
# - pidstat: stats par processus
pidstat 5                       # Toutes les 5 sec
pidstat -p PID 5

# Mémoire
# - free: utilisation mémoire
# - vmstat: stats virtuelles
vmstat 5
# - smem: mémoire par processus
sudo smem -s uss                # Trié par USS

# Disque
# - iostat: I/O stats
iostat -x 5
# - iotop: I/O par processus
# - iowait: temps CPU en attente I/O

# Réseau
# - iftop, nethogs
# - ss -s: stats sockets
# - netstat -s: stats protocoles

# === BENCHMARKING ===

# sysbench - benchmark CPU
sysbench cpu --cpu-max-prime=20000 run

# Benchmark RAM
sysbench memory --memory-total-size=10G run

# dd - benchmark disque (basique)
dd if=/dev/zero of=/tmp/test bs=1M count=1024 oflag=direct
dd if=/tmp/test of=/dev/null bs=1M iflag=direct

# fio - benchmark I/O avancé
fio --name=random-read --ioengine=libaio --rw=randread --bs=4k --size=1G --runtime=60

# iperf3 - benchmark réseau (déjà mentionné)

# bonnie++ - benchmark filesystem
bonnie++ -u root

# === PROFILING ===

# perf (déjà mentionné)
sudo perf top
sudo perf record -a sleep 10
sudo perf report

# flamegraph
git clone https://github.com/brendangregg/FlameGraph
sudo perf record -F 99 -a -g -- sleep 60
sudo perf script | ./FlameGraph/stackcollapse-perf.pl | ./FlameGraph/flamegraph.pl > flame.svg


Voici **5 grands énoncés d’exercices détaillés** pour la section **Performance & Optimisation**, adaptés à un Linux neuf avec peu de fichiers et utilisateurs :

---

# [BLEU] **EXERCICE 1 — Monitoring CPU, mémoire et I/O**

## **Énoncé détaillé**

1. Installez et utilisez les outils `iotop`, `atop` et `nethogs` :

   ```bash
   sudo apt install iotop atop nethogs
   sudo iotop -o
   atop 5
   sudo nethogs
   ```
2. Observez les processus qui consomment le plus de CPU et de mémoire.
3. Lancez un transfert réseau local ou un téléchargement et observez la bande passante avec `nethogs`.
4. Notez les colonnes clés (`IO`, `RES`, `%CPU`) et comprenez quelles ressources sont les plus sollicitées.
5. Sauvegardez un rapport des 5 premières lignes de `iotop` dans un fichier texte pour analyse ultérieure.

---

# [BLEU] **EXERCICE 2 — Collecte de statistiques avec sysstat**

## **Énoncé détaillé**

1. Installez `sysstat` :

   ```bash
   sudo apt install sysstat
   ```
2. Collectez les statistiques CPU toutes les 5 secondes, 5 fois :

   ```bash
   sar -u 5 5
   ```
3. Collectez la mémoire et l’I/O disque :

   ```bash
   sar -r 5 5
   sar -d 5 5
   ```
4. Analysez les résultats pour identifier les pics de CPU ou de I/O.
5. Exportez les résultats dans un fichier CSV pour étude graphique.

---

# [BLEU] **EXERCICE 3 — Tuning système et cache**

## **Énoncé détaillé**

1. Vérifiez la valeur actuelle de `swappiness` :

   ```bash
   cat /proc/sys/vm/swappiness
   ```
2. Modifiez temporairement `swappiness` pour réduire le swap :

   ```bash
   sudo sysctl -w vm.swappiness=10
   ```
3. Modifiez des paramètres réseau ou filesystem pour optimisation :

   ```bash
   sudo sysctl -w net.ipv4.tcp_rmem="4096 87380 67108864"
   sudo sysctl -w fs.file-max=65536
   ```
4. Videz les caches mémoire et observez la différence avec `free -h` :

   ```bash
   sudo sync; echo 3 | sudo tee /proc/sys/vm/drop_caches
   ```
5. Analysez les effets sur la performance après manipulation du cache.

---

# [BLEU] **EXERCICE 4 — Benchmarking CPU, RAM et disque**

## **Énoncé détaillé**

1. Installez `sysbench` et testez CPU et RAM :

   ```bash
   sudo apt install sysbench
   sysbench cpu --cpu-max-prime=20000 run
   sysbench memory --memory-total-size=1G run
   ```
2. Testez les performances disque avec `dd` :

   ```bash
   dd if=/dev/zero of=/tmp/test bs=1M count=512 oflag=direct
   dd if=/tmp/test of=/dev/null bs=1M iflag=direct
   ```
3. (Optionnel) Utilisez `fio` pour benchmark I/O avancé :

   ```bash
   sudo apt install fio
   fio --name=random-read --ioengine=libaio --rw=randread --bs=4k --size=512M --runtime=30
   ```
4. Comparez les résultats CPU, RAM et disque, et identifiez le goulot d’étranglement.
5. Notez dans un tableau les valeurs et discutez des optimisations possibles.

---

# [BLEU] **EXERCICE 5 — Analyse des processus et profiling**

## **Énoncé détaillé**

1. Lancez `pidstat` pour surveiller CPU par processus toutes les 5 secondes :

   ```bash
   pidstat 5
   ```
2. Identifiez les processus les plus gourmands et mesurez leur temps d’attente I/O.
3. Installez `perf` et générez un profil basique d’un processus inoffensif (ex: `sleep`) :

   ```bash
   sudo perf record -a sleep 10
   sudo perf report
   ```
4. (Optionnel) Installez `FlameGraph` et générez un graphe simplifié :

   ```bash
   git clone https://github.com/brendangregg/FlameGraph
   sudo perf record -F 99 -a -g -- sleep 10
   sudo perf script | ./FlameGraph/stackcollapse-perf.pl | ./FlameGraph/flamegraph.pl > flame.svg
   ```
5. Analysez et interprétez les résultats pour comprendre où le système consomme le plus de ressources.

---


[OK] GESTION MÉMOIRE & PROCESSUS AVANCÉ

# === INFORMATIONS MÉMOIRE DÉTAILLÉES ===

# /proc/meminfo - info détaillée
cat /proc/meminfo
grep -i active /proc/meminfo

# Mémoire par processus
cat /proc/PID/status | grep -i vm
cat /proc/PID/smaps             # Détails mappings mémoire
pmap PID                        # Memory map
pmap -x PID                     # Étendu

# === OOM KILLER ===

# Out Of Memory killer - tue processus quand mémoire pleine

# Voir OOM score
cat /proc/PID/oom_score
cat /proc/PID/oom_score_adj

# Ajuster priorité OOM (-1000 à 1000)
echo -17 | sudo tee /proc/PID/oom_score_adj

# Désactiver OOM pour processus
echo -1000 | sudo tee /proc/PID/oom_score_adj

# Logs OOM
dmesg | grep -i "out of memory"
grep -i "out of memory" /var/log/syslog

# === CGROUPS (Control Groups) ===

# Voir cgroups d'un processus
cat /proc/PID/cgroup

# Systemd utilise cgroups automatiquement

# Créer cgroup manuel
sudo cgcreate -g memory,cpu:/mygroup

# Limiter mémoire
echo 512M | sudo tee /sys/fs/cgroup/memory/mygroup/memory.limit_in_bytes

# Assigner processus à cgroup
sudo cgclassify -g memory,cpu:/mygroup PID

# Exécuter dans cgroup
sudo cgexec -g memory,cpu:/mygroup command

# === NAMESPACES ===

# Voir namespaces
ls -la /proc/PID/ns/

# Types de namespaces:
# - mnt: mount points
# - pid: process IDs
# - net: network
# - ipc: IPC
# - uts: hostname
# - user: user/group IDs

# unshare - créer namespace
unshare --fork --pid --mount-proc bash
# Maintenant dans nouveau PID namespace

# nsenter - entrer dans namespace
sudo nsenter -t PID -n -p bash
# Entre dans network et PID namespace du processus

# === NICE & RENICE (déjà couvert) ===

# Voir section PROCESSUS

# === IONICE - PRIORITÉ I/O ===

# Classes:
# 0: none (utilise défaut)
# 1: realtime (highest)
# 2: best-effort (défaut)
# 3: idle (lowest)

# Définir priorité I/O
ionice -c 2 -n 4 command        # Best-effort, niveau 4
ionice -c 3 command             # Idle class

# Changer priorité processus existant
ionice -c 2 -n 0 -p PID


Voici **5 grands énoncés d’exercices détaillés** pour la section **Gestion mémoire & processus avancé**, adaptés à un Linux neuf avec peu de fichiers et utilisateurs :

---

# [BLEU] **EXERCICE 1 — Analyse détaillée de la mémoire**

## **Énoncé détaillé**

1. Affichez les informations globales de mémoire du système :

   ```bash
   cat /proc/meminfo
   grep -i active /proc/meminfo
   ```
2. Lancez un processus simple (ex: `sleep 300`) et récupérez son PID.
3. Analysez sa consommation mémoire détaillée :

   ```bash
   cat /proc/PID/status | grep -i vm
   pmap PID
   pmap -x PID
   ```
4. Identifiez les sections mémoire principales (heap, stack, code, data).
5. Notez les différences entre la mémoire virtuelle et la mémoire RSS (resident).

---

# [BLEU] **EXERCICE 2 — OOM Killer et gestion des priorités mémoire**

## **Énoncé détaillé**

1. Créez un petit script qui consomme beaucoup de mémoire (ex: allocation répétée avec `yes > /dev/null &`).
2. Observez si le processus est tué par l’OOM killer :

   ```bash
   dmesg | grep -i "out of memory"
   grep -i "out of memory" /var/log/syslog
   ```
3. Vérifiez l’oom_score et l’oom_score_adj du processus :

   ```bash
   cat /proc/PID/oom_score
   cat /proc/PID/oom_score_adj
   ```
4. Modifiez la priorité OOM pour protéger un processus critique :

   ```bash
   echo -1000 | sudo tee /proc/PID/oom_score_adj
   ```
5. Relancez le script et observez que le processus protégé n’est pas tué.

---

# [BLEU] **EXERCICE 3 — Contrôle des ressources avec cgroups**

## **Énoncé détaillé**

1. Installez le package cgroup-tools si nécessaire :

   ```bash
   sudo apt install cgroup-tools
   ```
2. Créez un cgroup mémoire et CPU :

   ```bash
   sudo cgcreate -g memory,cpu:/mygroup
   ```
3. Limitez la mémoire à 256 Mo pour ce cgroup :

   ```bash
   echo 256M | sudo tee /sys/fs/cgroup/memory/mygroup/memory.limit_in_bytes
   ```
4. Exécutez un processus dans ce cgroup :

   ```bash
   sudo cgexec -g memory,cpu:/mygroup stress --vm 1 --vm-bytes 300M --vm-keep
   ```
5. Observez le comportement lorsque la limite mémoire est dépassée (processus tué).

---

# [BLEU] **EXERCICE 4 — Exploration des namespaces**

## **Énoncé détaillé**

1. Vérifiez les namespaces d’un processus existant :

   ```bash
   ls -la /proc/PID/ns/
   ```
2. Créez un nouveau PID namespace :

   ```bash
   unshare --fork --pid --mount-proc bash
   ```
3. Lancez quelques processus dans ce namespace et observez les PID depuis le namespace et depuis le système hôte.
4. Créez un network namespace simple et observez les interfaces réseau :

   ```bash
   sudo ip netns add testns
   sudo ip netns exec testns ip a
   ```
5. Entrez dans un namespace existant avec `nsenter` et listez les processus ou interfaces réseau.

---

# [BLEU] **EXERCICE 5 — Gestion avancée des priorités I/O**

## **Énoncé détaillé**

1. Installez `ionice` si nécessaire :

   ```bash
   sudo apt install util-linux
   ```
2. Lancez un processus consommateur d’I/O (ex: `dd if=/dev/zero of=/tmp/test bs=1M count=1024`).
3. Changez sa priorité I/O :

   ```bash
   ionice -c 3 -p PID        # Classe idle
   ionice -c 2 -n 0 -p PID    # Best-effort, priorité élevée
   ```
4. Lancez plusieurs processus I/O avec des priorités différentes et observez l’effet sur le temps d’exécution.
5. Documentez la différence de performance et expliquez quand utiliser `ionice` en production.

---


[OK] CONTENEURS & VIRTUALISATION

# === DOCKER ===

# Installation (Ubuntu)
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

# Commandes basiques
docker version
docker info
docker ps                       # Conteneurs en cours
docker ps -a                    # Tous conteneurs
docker images                   # Images

# Exécuter conteneur
docker run ubuntu
docker run -it ubuntu bash      # Interactif
docker run -d nginx             # Détaché (background)
docker run -p 8080:80 nginx     # Port mapping
docker run -v /host:/container nginx  # Volume mount
docker run --name mycontainer nginx
docker run --rm ubuntu          # Supprimer après arrêt

# Gérer conteneurs
docker start container
docker stop container
docker restart container
docker rm container             # Supprimer
docker rm -f container          # Force
docker logs container
docker logs -f container        # Follow
docker exec -it container bash  # Entrer dans conteneur
docker inspect container
docker stats                    # Stats temps réel

# Images
docker pull image:tag
docker build -t myimage .
docker tag image:tag newname:tag
docker push image:tag
docker rmi image                # Supprimer image

# Nettoyer
docker system prune             # Supprimer ressources inutilisées
docker system prune -a          # Tout supprimer
docker volume prune
docker image prune

# Docker Compose
docker-compose up
docker-compose up -d
docker-compose down
docker-compose ps
docker-compose logs -f

# === PODMAN (alternative Docker) ===

# Commandes similaires à Docker
podman run -d nginx
podman ps
podman images
podman pod create --name mypod
podman pod start mypod

# === LXC/LXD ===

# LXD - conteneurs système
lxc launch ubuntu:22.04 mycontainer
lxc list
lxc start mycontainer
lxc stop mycontainer
lxc exec mycontainer -- bash
lxc file push local.txt mycontainer/root/
lxc delete mycontainer

# === VIRTUALBOX ===

# Ligne de commande
VBoxManage list vms
VBoxManage startvm "VM Name"
VBoxManage controlvm "VM Name" poweroff
VBoxManage snapshot "VM Name" take "Snapshot Name"

# === KVM/QEMU ===

# Vérifier support virtualisation
egrep -c '(vmx|svm)' /proc/cpuinfo
lscpu | grep Virtualization

# Installer
sudo apt install qemu-kvm libvirt-daemon-system

# virsh - gérer VMs
virsh list --all
virsh start vm-name
virsh shutdown vm-name
virsh destroy vm-name           # Force stop
virsh undefine vm-name
virsh snapshot-create-as vm-name snapshot-name

# === VAGRANT ===

# Initialiser
vagrant init ubuntu/focal64
vagrant up
vagrant ssh
vagrant halt
vagrant destroy
vagrant status


Voici **5 grands énoncés d’exercices détaillés** couvrant toute la section **Conteneurs & Virtualisation**, adaptés à un Linux neuf avec peu de fichiers et utilisateurs :

---

# [BLEU] **EXERCICE 1 — Docker : premier conteneur et interaction**

## **Énoncé détaillé**

1. Installez Docker sur votre système (Ubuntu) et ajoutez votre utilisateur au groupe docker.
2. Vérifiez l’installation avec `docker version` et `docker info`.
3. Lancez un conteneur Ubuntu en mode interactif :

   ```bash
   docker run -it ubuntu bash
   ```
4. À l’intérieur du conteneur : créez un fichier `test.txt` et vérifiez qu’il existe.
5. Sortez du conteneur et observez qu’il est toujours actif avec `docker ps -a`.
6. Supprimez le conteneur et vérifiez qu’il n’apparaît plus.

---

# [BLEU] **EXERCICE 2 — Docker : volumes et port mapping**

## **Énoncé détaillé**

1. Lancez un conteneur Nginx en arrière-plan avec un port mappé :

   ```bash
   docker run -d -p 8080:80 nginx
   ```
2. Accédez au serveur via un navigateur ou `curl http://localhost:8080`.
3. Montez un volume local pour persister les fichiers :

   ```bash
   docker run -v /home/$USER/data:/usr/share/nginx/html -d nginx
   ```
4. Ajoutez un fichier HTML dans `/home/$USER/data` et vérifiez qu’il est servi par Nginx.
5. Inspectez les logs du conteneur avec `docker logs -f container_id`.

---

# [BLEU] **EXERCICE 3 — Gestion des conteneurs et images Docker**

## **Énoncé détaillé**

1. Téléchargez une image Ubuntu spécifique avec `docker pull ubuntu:22.04`.
2. Créez et lancez un conteneur à partir de cette image.
3. Exécutez une commande à l’intérieur du conteneur sans y entrer :

   ```bash
   docker exec container_id ls /
   ```
4. Construisez une image personnalisée avec un Dockerfile simple (ajoutez un fichier dans `/app`).
5. Supprimez les conteneurs et images inutilisés avec `docker system prune -a`.

---

# [BLEU] **EXERCICE 4 — LXC/LXD : conteneur système léger**

## **Énoncé détaillé**

1. Installez LXD et initialisez-le avec `lxd init`.
2. Lancez un conteneur Ubuntu 22.04 :

   ```bash
   lxc launch ubuntu:22.04 mycontainer
   ```
3. Entrez dans le conteneur et créez un fichier `hello.txt`.
4. Copiez un fichier depuis l’hôte vers le conteneur avec `lxc file push`.
5. Arrêtez puis supprimez le conteneur avec `lxc stop` et `lxc delete`.

---

# [BLEU] **EXERCICE 5 — Virtualisation avec Vagrant et KVM**

## **Énoncé détaillé**

1. Installez Vagrant et VirtualBox (ou KVM/QEMU).
2. Initialisez une VM Vagrant Ubuntu :

   ```bash
   vagrant init ubuntu/focal64
   vagrant up
   ```
3. Connectez-vous à la VM avec `vagrant ssh` et créez un fichier test.
4. Prenez un snapshot de la VM avec VirtualBox ou `virsh snapshot-create-as` si KVM.
5. Arrêtez puis restaurez la VM à son snapshot, puis détruisez-la avec `vagrant destroy`.

---


[OK] TEXTE & ÉDITEURS AVANCÉS

# === VIM AVANCÉ ===

# Modes Vim:
# Normal (Esc)
# Insert (i, a, o)
# Visual (v, V, Ctrl+v)
# Command (:)

# Navigation avancée
gg                              # Début fichier
G                               # Fin fichier
10G                             # Ligne 10
0                               # Début ligne
$                               # Fin ligne
w                               # Mot suivant
b                               # Mot précédent
{                               # Paragraphe précédent
}                               # Paragraphe suivant

# Édition avancée
ciw                             # Change inner word
ci"                             # Change dans guillemets
di(                             # Delete dans parenthèses
yap                             # Yank paragraph
>                               # Indent
<                               # Unindent
==                              # Auto-indent ligne
gg=G                            # Auto-indent fichier

# Recherche/Remplacement
/pattern                        # Rechercher
?pattern                        # Rechercher backward
n                               # Suivant
N                               # Précédent
*                               # Rechercher mot sous curseur
:%s/old/new/g                   # Remplacer tout
:%s/old/new/gc                  # Avec confirmation
:5,10s/old/new/g                # Lignes 5-10

# Fenêtres multiples
:split                          # Split horizontal
:vsplit                         # Split vertical
Ctrl+w w                        # Changer fenêtre
Ctrl+w q                        # Fermer fenêtre
:tabnew                         # Nouvel onglet
gt                              # Onglet suivant
gT                              # Onglet précédent

# Macros
qa                              # Enregistrer macro dans registre a
q                               # Arrêter enregistrement
@a                              # Exécuter macro a
@@                              # Répéter dernière macro

# Marks
ma                              # Définir mark a
'a                              # Aller au mark a
:marks                          # Lister marks

# Configuration (~/.vimrc)
# set number                    " Numéros lignes
# set relativenumber            " Numéros relatifs
# set tabstop=4
# set shiftwidth=4
# set expandtab                 " Espaces au lieu de tabs
# syntax on
# set hlsearch                  " Highlight search
# set incsearch                 " Incremental search
# set ignorecase
# set smartcase

# === EMACS BASIQUE ===

# Notation:
# C-x : Ctrl+x
# M-x : Alt+x ou Esc puis x

# Basique
C-x C-f                         # Ouvrir fichier
C-x C-s                         # Sauvegarder
C-x C-c                         # Quitter
C-g                             # Annuler commande

# Navigation
C-a                             # Début ligne
C-e                             # Fin ligne
M-<                             # Début buffer
M->                             # Fin buffer
C-v                             # Page suivante
M-v                             # Page précédente

# Édition
C-d                             # Supprimer caractère
M-d                             # Supprimer mot
C-k                             # Kill ligne
C-y                             # Yank (paste)
C-w                             # Cut region
M-w                             # Copy region

# Recherche
C-s                             # Recherche forward
C-r                             # Recherche backward
M-%                             # Query replace

# === EXPRESSIONS RÉGULIÈRES ===

# Métacaractères basiques
.                               # N'importe quel caractère
^                               # Début ligne
$                               # Fin ligne
*                               # 0 ou plus
+                               # 1 ou plus
?                               # 0 ou 1
[abc]                           # Classe caractères
[^abc]                          # Négation
[a-z]                           # Range
\d                              # Chiffre
\w                              # Word character
\s                              # Whitespace
|                               # OU
()                              # Groupement

# Exemples grep
grep '^root' /etc/passwd        # Lignes commençant par root
grep 'bash# Fichier: python_cheats/cheatsheets/linux.txt
# Cheatsheet Linux - Guide Complet & Exhaustif

Voici **5 grands énoncés d’exercices détaillés** couvrant toute la section **Texte & Éditeurs avancés**, adaptés à un Linux neuf avec peu de fichiers et utilisateurs :

---

# [BLEU] **EXERCICE 1 — Navigation et édition avancée avec Vim**

## **Énoncé détaillé**

1. Créez un fichier texte `exercice.txt` avec plusieurs paragraphes et lignes.
2. Ouvrez-le dans Vim et :

   * Naviguez au début et à la fin du fichier (`gg`, `G`).
   * Allez à la ligne 5 (`5G`) et au mot suivant (`w`) ou précédent (`b`).
3. Modifiez le texte :

   * Changez un mot (`ciw`) et un mot entre guillemets (`ci"`).
   * Supprimez du texte entre parenthèses (`di(`).
4. Copiez un paragraphe (`yap`) et collez-le ailleurs.
5. Testez l’indentation automatique sur le fichier (`gg=G`).

---

# [BLEU] **EXERCICE 2 — Recherche, remplacement et macros Vim**

## **Énoncé détaillé**

1. Dans le fichier `exercice.txt`, recherchez toutes les occurrences d’un mot avec `/mot`.
2. Remplacez globalement un mot par un autre avec confirmation :

   ```vim
   :%s/ancien/nouveau/gc
   ```
3. Créez une macro qui ajoute un texte au début de chaque ligne et appliquez-la sur plusieurs lignes.
4. Définissez et utilisez un mark pour revenir rapidement à une position spécifique dans le fichier (`ma`, `'a`).
5. Ouvrez un split vertical (`:vsplit`) et un split horizontal (`:split`), naviguez entre eux (`Ctrl+w w`) et fermez-les (`Ctrl+w q`).

---

# [BLEU] **EXERCICE 3 — Configuration Vim et personnalisations**

## **Énoncé détaillé**

1. Créez un fichier de configuration `~/.vimrc` avec :

   * Numéros de ligne et numéros relatifs
   * Tabulations transformées en espaces
   * Highlight sur recherche
   * Syntaxe activée
2. Ouvrez un fichier long et vérifiez que la configuration s’applique automatiquement.
3. Testez la recherche incrémentale (`set incsearch`) et le cas intelligent (`set ignorecase`, `set smartcase`).
4. Ajoutez un raccourci simple pour enregistrer et quitter rapidement via une macro dans `.vimrc`.
5. Testez le résultat en éditant et sauvegardant un fichier existant.

---

# [BLEU] **EXERCICE 4 — Emacs basique et édition de texte**

## **Énoncé détaillé**

1. Installez Emacs et ouvrez un fichier `exercice_emacs.txt`.
2. Apprenez les raccourcis :

   * Ouvrir (`C-x C-f`) et sauvegarder (`C-x C-s`)
   * Navigation : début/fin ligne (`C-a`, `C-e`), début/fin buffer (`M-<`, `M->`)
   * Page suivante/précédente (`C-v`, `M-v`)
3. Éditez le texte : supprimez un mot (`M-d`), une ligne (`C-k`) et copiez-collez une région (`C-w`, `C-y`).
4. Testez la recherche (`C-s`, `C-r`) et le remplacement (`M-%`).
5. Fermez Emacs proprement (`C-x C-c`).

---

# [BLEU] **EXERCICE 5 — Expressions régulières et grep**

## **Énoncé détaillé**

1. Créez un fichier texte avec différentes lignes contenant des emails, nombres et mots variés.
2. Testez des expressions régulières avec `grep` :

   * Lignes commençant par un mot spécifique (`^mot`)
   * Lignes se terminant par un caractère précis (`mot$`)
   * Toutes les lignes contenant un chiffre (`\d`) ou un mot (`\w`)
3. Testez les classes et ranges `[a-z]`, `[0-9]`, négation `[^a-z]`.
4. Combinez des motifs avec l’opérateur OU (`pattern1|pattern2`).
5. Faites un remplacement dans un fichier avec `sed` pour appliquer une regex simple.

---


[OK] NAVIGATION & SYSTÈME DE FICHIERS

# === DÉPLACEMENT ===

# Afficher répertoire courant
pwd
pwd -P                          # Chemin physique (résout symlinks)
pwd -L                          # Chemin logique (avec symlinks)

# Changer de répertoire
cd /chemin/absolu
cd chemin/relatif
cd ..                           # Répertoire parent
cd ../..                        # Deux niveaux au-dessus
cd -                            # Répertoire précédent
cd ~                            # Répertoire home
cd                              # Répertoire home (équivalent)
cd ~/Documents
cd ~username                    # Home d'un autre utilisateur

# Répertoires spéciaux
.                               # Répertoire courant
..                              # Répertoire parent
~                               # Home de l'utilisateur courant
~username                       # Home d'un utilisateur spécifique
/                               # Racine du système
-                               # Répertoire précédent (avec cd)

# === LISTER FICHIERS & RÉPERTOIRES ===

# Liste basique
ls
ls -l                           # Format long (détails)
ls -la                          # Tout inclure (fichiers cachés)
ls -lh                          # Tailles lisibles (human-readable)
ls -lS                          # Trier par taille
ls -lt                          # Trier par date de modification
ls -ltr                         # Trier par date (inverse)
ls -lR                          # Récursif
ls -ld */                       # Seulement répertoires
ls -1                           # Un fichier par ligne

# Options avancées
ls -la --color=auto             # Avec couleurs
ls -li                          # Avec numéros d'inodes
ls -lh --block-size=M           # Tailles en MB
ls -X                           # Trier par extension
ls --group-directories-first    # Répertoires en premier
ls -F                           # Ajoute indicateurs (/ pour dirs, * pour executables)
ls -Q                           # Noms entre guillemets
ls --time=atime                 # Trier par dernier accès
ls --time=ctime                 # Trier par changement metadata

# Filtres et patterns
ls *.txt                        # Tous les .txt
ls file?.txt                    # file1.txt, fileA.txt, etc.
ls file[1-3].txt                # file1.txt, file2.txt, file3.txt
ls [abc]*                       # Commence par a, b ou c
ls *[!0-9]                      # Ne finit pas par un chiffre

# Alternatives modernes
exa -la                         # Alternative moderne à ls (nécessite installation)
lsd -la                         # LSD (LSDeluxe) - ls moderne
tree                            # Vue arborescente
tree -L 2                       # Limiter profondeur à 2 niveaux
tree -d                         # Seulement répertoires
tree -I 'node_modules|.git'     # Exclure patterns

# === CRÉER FICHIERS & RÉPERTOIRES ===

# Créer fichiers
touch file.txt                  # Crée fichier vide ou met à jour timestamp
touch file1.txt file2.txt       # Créer plusieurs fichiers
touch {1..10}.txt               # Crée 1.txt, 2.txt, ..., 10.txt
touch file{A..Z}.txt            # fileA.txt à fileZ.txt

# Options touch
touch -c file.txt               # N'crée pas si n'existe pas
touch -t 202301011200.00 file   # Définir date/heure spécifique
touch -d "2 hours ago" file     # Date relative
touch -r ref.txt file.txt       # Copier timestamp de ref.txt

# Créer répertoires
mkdir dir
mkdir -p path/to/deep/dir       # Créer tous parents nécessaires
mkdir -v dir                    # Verbose (affiche création)
mkdir -m 755 dir                # Avec permissions spécifiques
mkdir dir{1..5}                 # dir1, dir2, dir3, dir4, dir5
mkdir -p project/{src,tests,docs}

# === COPIER, DÉPLACER, SUPPRIMER ===

# Copier
cp source.txt dest.txt
cp source.txt /path/to/dest/
cp file1 file2 file3 dest_dir/
cp -r dir1/ dir2/               # Copier répertoire (récursif)
cp -a source/ dest/             # Archive mode (préserve tout)
cp -u source dest               # Seulement si source plus récent
cp -i source dest               # Interactif (demande confirmation)
cp -n source dest               # Ne pas écraser
cp -v source dest               # Verbose
cp -p source dest               # Préserve attributs
cp -L source dest               # Suivre symlinks

# Copier avec rsync (plus puissant)
rsync -av source/ dest/         # Archive + verbose
rsync -avz source/ dest/        # Avec compression
rsync -av --progress source/ dest/
rsync -av --exclude='*.log' source/ dest/
rsync -av --delete source/ dest/  # Synchronisation (supprime dans dest)

# Déplacer/Renommer
mv old.txt new.txt              # Renommer
mv file.txt /path/to/dest/      # Déplacer
mv file1 file2 file3 dest_dir/
mv -i source dest               # Interactif
mv -u source dest               # Seulement si plus récent
mv -v source dest               # Verbose
mv -n source dest               # Ne pas écraser

# Supprimer
rm file.txt
rm file1 file2 file3
rm -r dir/                      # Répertoire (récursif)
rm -rf dir/                     # Force + récursif (ATTENTION!)
rm -i file.txt                  # Interactif
rm -v file.txt                  # Verbose
rm -- -file.txt                 # Fichier commençant par -
rm ./-file.txt                  # Alternative

# Supprimer en toute sécurité
trash file.txt                  # Envoyer à la corbeille (si trash-cli installé)
rm -I *.txt                     # Demande confirmation pour >3 fichiers

# Vider répertoire mais garder la structure
find dir/ -type f -delete
rm -rf dir/* dir/.*             # ATTENTION: supprime tout

# === LIENS SYMBOLIQUES & HARD LINKS ===

# Créer lien symbolique (symlink)
ln -s /path/to/original link_name
ln -s ../file.txt link.txt      # Relatif
ln -sf original link            # Force (écrase si existe)
ln -sv original link            # Verbose

# Créer hard link
ln original hardlink

# Différences:
# Symlink: pointeur vers fichier (peut traverser systèmes de fichiers)
# Hard link: référence directe aux données (même inode, même filesystem)

# Afficher cible d'un symlink
readlink link_name
readlink -f link_name           # Chemin absolu résolu
ls -l link_name                 # Affiche aussi la cible

# Trouver tous les symlinks
find /path -type l
find /path -type l -ls

# Trouver symlinks cassés
find /path -xtype l


[OK] AFFICHAGE & MANIPULATION DE FICHIERS

# === LIRE FICHIERS ===

# Afficher contenu complet
cat file.txt
cat file1.txt file2.txt         # Concaténer plusieurs fichiers
cat -n file.txt                 # Avec numéros de lignes
cat -b file.txt                 # Numéros seulement lignes non-vides
cat -A file.txt                 # Afficher tous caractères spéciaux
cat -s file.txt                 # Supprimer lignes vides multiples

# Afficher début de fichier
head file.txt                   # 10 premières lignes
head -n 20 file.txt             # 20 premières lignes
head -n -5 file.txt             # Tout sauf 5 dernières lignes
head -c 100 file.txt            # 100 premiers octets

# Afficher fin de fichier
tail file.txt                   # 10 dernières lignes
tail -n 20 file.txt             # 20 dernières lignes
tail -n +10 file.txt            # Depuis ligne 10
tail -f file.txt                # Suivre fichier en temps réel
tail -F file.txt                # Suit même si fichier recréé
tail -f file.txt --pid=12345    # Arrête quand processus 12345 termine

# Afficher avec pagination
less file.txt                   # Navigation avancée
more file.txt                   # Pagination basique

# Commandes dans less:
# Espace: page suivante
# b: page précédente
# /pattern: rechercher
# n: occurrence suivante
# N: occurrence précédente
# g: début du fichier
# G: fin du fichier
# q: quitter

# Options less utiles
less -N file.txt                # Avec numéros de lignes
less -S file.txt                # Ne pas wrapper lignes longues
less +F file.txt                # Mode follow (comme tail -f)
less -R file.txt                # Interpréter couleurs ANSI

# Afficher fichiers binaires
xxd file.bin                    # Hexdump
hexdump -C file.bin
od -x file.bin                  # Octal dump

# Compter
wc file.txt                     # Lignes, mots, octets
wc -l file.txt                  # Seulement lignes
wc -w file.txt                  # Seulement mots
wc -c file.txt                  # Seulement octets
wc -m file.txt                  # Seulement caractères
wc -L file.txt                  # Longueur ligne la plus longue

# === RECHERCHE DANS FICHIERS ===

# grep - recherche de patterns
grep "pattern" file.txt
grep -i "pattern" file.txt      # Insensible à la casse
grep -r "pattern" dir/          # Récursif
grep -n "pattern" file.txt      # Avec numéros de lignes
grep -v "pattern" file.txt      # Inverser (lignes ne contenant PAS pattern)
grep -c "pattern" file.txt      # Compter occurrences
grep -l "pattern" *.txt         # Seulement noms de fichiers
grep -w "word" file.txt         # Mot complet seulement
grep -A 3 "pattern" file.txt    # 3 lignes après
grep -B 3 "pattern" file.txt    # 3 lignes avant
grep -C 3 "pattern" file.txt    # 3 lignes avant et après
grep -E "regex" file.txt        # Expressions régulières étendues
grep -P "regex" file.txt        # Perl regex
grep -o "pattern" file.txt      # Seulement partie correspondante

# Recherche multiple
grep -e "pattern1" -e "pattern2" file.txt
grep "pattern1\|pattern2" file.txt

# Exclure fichiers/dossiers
grep -r "pattern" --exclude="*.log" dir/
grep -r "pattern" --exclude-dir=node_modules dir/

# Alternatives modernes
rg "pattern" dir/               # ripgrep (très rapide, nécessite install)
rg -i "pattern"                 # Insensible casse
rg -l "pattern"                 # Seulement noms fichiers
ag "pattern" dir/               # silver searcher (nécessite install)

# === ÉDITION DE FICHIERS ===

# Éditeurs en ligne de commande
nano file.txt                   # Éditeur simple
vim file.txt                    # Éditeur puissant
vi file.txt                     # Vi (ancêtre de vim)
emacs file.txt                  # Emacs

# Commandes nano:
# Ctrl+O: sauvegarder
# Ctrl+X: quitter
# Ctrl+K: couper ligne
# Ctrl+U: coller
# Ctrl+W: rechercher

# Commandes vim basiques:
# i: mode insertion
# Esc: mode normal
# :w: sauvegarder
# :q: quitter
# :wq ou :x: sauvegarder et quitter
# :q!: quitter sans sauvegarder
# dd: supprimer ligne
# yy: copier ligne
# p: coller
# u: undo
# Ctrl+r: redo
# /pattern: rechercher
# :%s/old/new/g: remplacer tout

# sed - édition de flux
sed 's/old/new/' file.txt       # Remplacer première occurrence
sed 's/old/new/g' file.txt      # Remplacer toutes occurrences
sed 's/old/new/gi' file.txt     # Insensible casse
sed -i 's/old/new/g' file.txt   # Modifier fichier en place
sed -i.bak 's/old/new/g' file.txt  # Avec backup
sed '3d' file.txt               # Supprimer ligne 3
sed '1,5d' file.txt             # Supprimer lignes 1-5
sed -n '10,20p' file.txt        # Afficher lignes 10-20
sed '/pattern/d' file.txt       # Supprimer lignes contenant pattern
sed 's/^/prefix_/' file.txt     # Ajouter préfixe à chaque ligne
sed 's/$/suffix/' file.txt      # Ajouter suffixe

# awk - traitement de texte puissant
awk '{print $1}' file.txt       # Afficher première colonne
awk '{print $1, $3}' file.txt   # Colonnes 1 et 3
awk -F: '{print $1}' /etc/passwd  # Délimiteur personnalisé
awk 'NR==5' file.txt            # Ligne 5
awk 'NR>=5 && NR<=10' file.txt  # Lignes 5-10
awk '/pattern/' file.txt        # Lignes contenant pattern
awk '{sum+=$1} END {print sum}' file.txt  # Somme colonne 1
awk 'length>80' file.txt        # Lignes de plus de 80 caractères
awk '{print NF}' file.txt       # Nombre de colonnes par ligne

# cut - extraire colonnes
cut -d: -f1 /etc/passwd         # Première colonne (délimiteur :)
cut -d, -f1,3 file.csv          # Colonnes 1 et 3
cut -c1-10 file.txt             # Caractères 1-10
cut -f2- file.txt               # Colonne 2 jusqu'à la fin

# sort - trier
sort file.txt                   # Tri alphabétique
sort -n file.txt                # Tri numérique
sort -r file.txt                # Ordre inverse
sort -u file.txt                # Unique (supprime doublons)
sort -k2 file.txt               # Trier par colonne 2
sort -t: -k3 -n /etc/passwd     # Délimiteur perso, colonne 3, numérique
sort -h file.txt                # Tri "human" (1K, 1M, etc.)

# uniq - supprimer doublons adjacents
uniq file.txt                   # Supprimer doublons
uniq -c file.txt                # Compter occurrences
uniq -d file.txt                # Seulement doublons
uniq -u file.txt                # Seulement uniques
sort file.txt | uniq            # Supprimer TOUS doublons

# tr - transformer caractères
tr 'a-z' 'A-Z' < file.txt       # Minuscules vers majuscules
tr -d '\r' < file.txt           # Supprimer caractères
tr -s ' ' < file.txt            # Squeeze espaces multiples
tr '\n' ',' < file.txt          # Remplacer newlines par virgules

# paste - fusionner lignes
paste file1.txt file2.txt       # Colonnes côte à côte
paste -d, file1.txt file2.txt   # Avec délimiteur
paste -s file.txt               # Tout sur une ligne

# join - jointure de fichiers
join -t: -1 1 -2 1 file1.txt file2.txt

# === COMPRESSION & ARCHIVAGE ===

# tar - archivage
tar -cvf archive.tar dir/       # Créer archive
tar -cvzf archive.tar.gz dir/   # Créer archive gzip
tar -cvjf archive.tar.bz2 dir/  # Créer archive bzip2
tar -cvJf archive.tar.xz dir/   # Créer archive xz
tar -xvf archive.tar            # Extraire
tar -xvzf archive.tar.gz        # Extraire gzip
tar -xvf archive.tar -C /path/  # Extraire vers chemin spécifique
tar -tvf archive.tar            # Lister contenu
tar -xvf archive.tar file.txt   # Extraire fichier spécifique
tar --exclude='*.log' -cvzf archive.tar.gz dir/

# Options tar:
# c: créer
# x: extraire
# t: lister
# v: verbose
# f: fichier
# z: gzip
# j: bzip2
# J: xz

# gzip - compression
gzip file.txt                   # Compresser (remplace original)
gzip -k file.txt                # Garder original
gzip -9 file.txt                # Compression maximale
gzip -d file.txt.gz             # Décompresser
gunzip file.txt.gz              # Décompresser (équivalent)
gzip -r dir/                    # Récursif
gzip -l file.txt.gz             # Info compression

# bzip2 - compression (meilleure que gzip)
bzip2 file.txt
bzip2 -k file.txt               # Garder original
bzip2 -d file.txt.bz2
bunzip2 file.txt.bz2

# xz - compression (meilleure que bzip2)
xz file.txt
xz -k file.txt
xz -d file.txt.xz
unxz file.txt.xz

# zip - compression compatible Windows
zip archive.zip file.txt
zip -r archive.zip dir/         # Récursif
zip -e archive.zip file.txt     # Avec mot de passe
unzip archive.zip
unzip -l archive.zip            # Lister contenu
unzip archive.zip -d /path/     # Extraire vers chemin

# Autres formats
7z a archive.7z dir/            # Créer archive 7z
7z x archive.7z                 # Extraire
rar a archive.rar dir/          # Créer RAR
unrar x archive.rar             # Extraire RAR


[OK] PERMISSIONS & PROPRIÉTÉ

# === COMPRENDRE LES PERMISSIONS ===

# Format: drwxrwxrwx
# d: type (d=directory, -=file, l=link)
# rwx: user (propriétaire)
# rwx: group (groupe)
# rwx: others (autres)
#
# r (read): 4
# w (write): 2
# x (execute): 1

# === CHMOD - MODIFIER PERMISSIONS ===

# Mode symbolique
chmod u+x file.txt              # Ajouter exec pour user
chmod g-w file.txt              # Retirer write pour group
chmod o=r file.txt              # Définir others à read only
chmod a+r file.txt              # Ajouter read pour all
chmod u+x,g+x file.txt          # Multiple
chmod +x file.txt               # Ajouter exec pour all (raccourci)

# Mode numérique
chmod 755 file.txt              # rwxr-xr-x
chmod 644 file.txt              # rw-r--r--
chmod 600 file.txt              # rw-------
chmod 777 file.txt              # rwxrwxrwx (ÉVITER!)
chmod 700 dir/                  # rwx------ pour dir

# Permissions courantes:
# 644: fichiers normaux (rw-r--r--)
# 755: fichiers exécutables et dossiers (rwxr-xr-x)
# 600: fichiers privés (rw-------)
# 700: dossiers privés (rwx------)
# 777: tout le monde peut tout faire (DANGEREUX!)

# Récursif
chmod -R 755 dir/               # Récursif

# Permissions spéciales
chmod u+s file                  # SUID
chmod g+s dir                   # SGID
chmod +t dir                    # Sticky bit
chmod 4755 file                 # SUID + 755
chmod 2755 dir                  # SGID + 755
chmod 1755 dir                  # Sticky + 755

# === CHOWN - MODIFIER PROPRIÉTAIRE ===

# Changer propriétaire
sudo chown user file.txt
sudo chown user:group file.txt
sudo chown :group file.txt      # Seulement groupe
sudo chown -R user:group dir/   # Récursif

# Copier ownership d'un autre fichier
sudo chown --reference=ref.txt file.txt

# === CHGRP - MODIFIER GROUPE ===

sudo chgrp group file.txt
sudo chgrp -R group dir/

# === UMASK - PERMISSIONS PAR DÉFAUT ===

# Afficher umask
umask
umask -S                        # Format symbolique

# Définir umask
umask 022                       # Défaut: 755 pour dirs, 644 pour files
umask 077                       # Restrictif: 700 pour dirs, 600 pour files

# Calcul:
# Directories: 777 - umask
# Files: 666 - umask
# Exemple umask 022:
#   Dirs: 777 - 022 = 755
#   Files: 666 - 022 = 644

# === ACL - PERMISSIONS AVANCÉES ===

# Installer ACL (si nécessaire)
sudo apt install acl            # Debian/Ubuntu
sudo yum install acl            # RedHat/CentOS

# Afficher ACL
getfacl file.txt

# Définir ACL
setfacl -m u:username:rwx file.txt
setfacl -m g:groupname:rx file.txt
setfacl -m o::r file.txt
setfacl -R -m u:user:rwx dir/   # Récursif

# Supprimer ACL
setfacl -x u:username file.txt
setfacl -b file.txt             # Supprimer toutes les ACL

# ACL par défaut (pour nouveaux fichiers dans dir)
setfacl -d -m u:user:rwx dir/

# === ATTRIBUTS DE FICHIERS ===

# Afficher attributs
lsattr file.txt

# Modifier attributs
sudo chattr +i file.txt         # Immutable (non modifiable)
sudo chattr -i file.txt         # Retirer immutable
sudo chattr +a file.txt         # Append only
sudo chattr +A file.txt         # No atime update

# Attributs utiles:
# i: immutable (ne peut pas être modifié/supprimé)
# a: append-only (peut seulement ajouter)
# A: no atime (pas de mise à jour access time)
# s: secure deletion (écrasement sécurisé)
# u: undeletable (peut être récupéré après suppression)


[OK] RECHERCHE DE FICHIERS

# === FIND - RECHERCHE PUISSANTE ===

# Recherche basique
find /path -name "filename"
find /path -name "*.txt"
find . -name "file*"
find / -name "nginx.conf" 2>/dev/null  # Ignorer erreurs

# Options de nom
find /path -iname "*.txt"       # Insensible casse
find /path -name "*.txt" -o -name "*.log"  # OR
find /path -not -name "*.txt"   # Négation
find /path ! -name "*.txt"      # Négation (alternative)

# Par type
find /path -type f              # Fichiers
find /path -type d              # Répertoires
find /path -type l              # Liens symboliques
find /path -type s              # Sockets
find /path -type p              # Named pipes

# Par taille
find /path -size +100M          # Plus de 100MB
find /path -size -10k           # Moins de 10KB
find /path -size 50M            # Exactement 50MB
find /path -size +1G -size -5G  # Entre 1GB et 5GB

# Unités: c (bytes), k (KB), M (MB), G (GB)

# Par temps
find /path -mtime -7            # Modifié derniers 7 jours
find /path -mtime +30           # Modifié il y a plus de 30 jours
find /path -mmin -60            # Modifié dernières 60 minutes
find /path -atime -7            # Accédé derniers 7 jours
find /path -ctime -7            # Métadata changée derniers 7 jours

# Par permissions
find /path -perm 644            # Permissions exactes
find /path -perm -644           # Au moins ces permissions
find /path -perm /644           # N'importe laquelle de ces permissions
find /path -perm /u=w,g=w       # Writable par user OU group

# Par propriétaire
find /path -user username
find /path -group groupname
find /path -uid 1000
find /path -gid 1000
find /path -nouser              # Sans propriétaire
find /path -nogroup             # Sans groupe

# Profondeur
find /path -maxdepth 2          # Max 2 niveaux
find /path -mindepth 1          # Min 1 niveau
find /path -maxdepth 1 -type f  # Seulement ce niveau

# Actions
find /path -name "*.log" -delete
find /path -name "*.txt" -exec cat {} \;
find /path -name "*.txt" -exec mv {} /dest/ \;
find /path -name "*.txt" -ok rm {} \;  # Demande confirmation
find /path -type f -exec chmod 644 {} \;
find /path -type d -exec chmod 755 {} \;

# {} : représente fichier trouvé
# \; : fin de commande exec
# + : passer plusieurs fichiers à la fois (plus efficace)

find /path -name "*.txt" -exec grep "pattern" {} +

# Multiple critères
find /path -name "*.log" -size +100M -mtime +30

# Fichiers vides
find /path -empty
find /path -type f -empty       # Fichiers vides
find /path -type d -empty       # Répertoires vides

# Exclure répertoires
find /path -name node_modules -prune -o -name "*.js" -print
find /path -path "*/node_modules/*" -prune -o -type f -print

# Par contenu (nécessite -exec grep)
find /path -type f -exec grep -l "pattern" {} \;

# === LOCATE - RECHERCHE RAPIDE ===

# Mettre à jour base de données
sudo updatedb

# Rechercher
locate filename
locate "*.conf"
locate -i filename              # Insensible casse
locate -n 10 filename           # Limiter à 10 résultats
locate -c filename              # Compter résultats
locate -e filename              # Seulement si existe encore
locate -r "regex"               # Avec regex

# Statistiques
locate -S

# === WHEREIS - TROUVER BINAIRES ===

whereis command
whereis -b command              # Seulement binaire
whereis -m command              # Seulement man pages
whereis -s command              # Seulement sources

# === WHICH - TROUVER DANS PATH ===

which command
which -a command                # Tous les matches

# === TYPE - INFO SUR COMMANDE ===

type command
type -a command                 # Tous les types
type -t command                 # Type seulement


[OK] PROCESSUS & GESTION SYSTÈME

# === VOIR PROCESSUS ===

# ps - processus
ps                              # Processus du terminal actuel
ps aux                          # Tous processus (BSD style)
ps -ef                          # Tous processus (Unix style)
ps -u username                  # Processus d'un utilisateur
ps -C processname               # Processus par nom
ps --forest                     # Vue arborescente
ps aux --sort=-%mem             # Trier par mémoire
ps aux --sort=-%cpu             # Trier par CPU

# Colonnes ps:
# PID: Process ID
# USER: propriétaire
# %CPU: utilisation CPU
# %MEM: utilisation mémoire
# VSZ: mémoire virtuelle
# RSS: mémoire résidente
# STAT: état (R=running, S=sleeping, Z=zombie, T=stopped)
# TIME: temps CPU
# COMMAND: commande

# top - monitoring temps réel
top
top -u username                 # Filtrer par user
top -p 1234                     # Processus spécifique
top -d 5                        # Refresh toutes les 5 secondes

# Commandes dans top:
# q: quitter
# k: kill processus
# r: renice processus
# M: trier par mémoire
# P: trier par CPU
# 1: afficher tous CPU
# h: aide

# htop - top amélioré (nécessite installation)
htop
# Navigation avec flèches, F9 pour kill, F6 pour trier

# === CONTRÔLE PROCESSUS ===

# Lancer processus
command
command &                       # En arrière-plan
nohup command &                 # Continue après déconnexion
nohup command > output.log 2>&1 &

# Jobs (processus du terminal)
jobs                            # Lister jobs
jobs -l                         # Avec PID

# Foreground/Background
fg                              # Ramener dernier job en avant
fg %1                           # Job 1 en avant
bg                              # Continuer dernier job en arrière-plan
bg %1                           # Job 1 en arrière-plan

# Suspendre processus
Ctrl+Z                          # Suspendre processus actuel

# === KILL PROCESSUS ===

# kill - envoyer signal
kill PID                        # SIGTERM (terminaison propre)
kill -9 PID                     # SIGKILL (force, brutal)
kill -15 PID                    # SIGTERM (explicite)
kill -SIGTERM PID               # Avec nom de signal
kill -l                         # Lister tous les signaux

# Signaux courants:
# 1  SIGHUP: hangup
# 2  SIGINT: interrupt (Ctrl+C)
# 9  SIGKILL: kill force (non capturable)
# 15 SIGTERM: terminate (propre)
# 18 SIGCONT: continue
# 19 SIGSTOP: stop
# 20 SIGTSTP: terminal stop (Ctrl+Z)

# killall - kill par nom
killall processname
killall -9 processname
killall -u username             # Tous processus d'un user
killall -i processname          # Interactif

# pkill - kill par pattern
pkill processname
pkill -9 processname
pkill -u username
pkill -f "script.py"            # Pattern sur ligne commande complète

# pgrep - trouver PID par pattern
pgrep processname
pgrep -u username
pgrep -l processname            # Avec nom
pgrep -a processname            # Avec commande complète

# === PRIORITÉ PROCESSUS ===

# nice - lancer avec priorité
nice -n 10 command              # Nice +10 (priorité basse)
nice -n -10 command             # Nice -10 (priorité haute, nécessite root)

# Valeurs nice: -20 (haute priorité) à 19 (basse priorité)
# Défaut: 0

# renice - changer priorité processus existant
renice 10 -p PID
renice 10 -u username
sudo renice -10 -p PID          # Priorité haute (root requis)

# === MONITORING SYSTÈME ===

# uptime - temps de fonctionnement
uptime
uptime -p                       # Format lisible
uptime -s                       # Depuis quand

# free - mémoire
free
free -h                         # Human readable
free -m                         # En MB
free -g                         # En GB
free -s 5                       # Rafraîchir toutes les 5 sec

# vmstat - statistiques système
vmstat                          # Vue d'ensemble
vmstat 5                        # Mise à jour toutes les 5 sec
vmstat -s                       # Statistiques mémoire
vmstat -d                       # Statistiques disque

# iostat - statistiques I/O
iostat
iostat -x                       # Étendu
iostat 5                        # Toutes les 5 sec
iostat -d                       # Seulement disques

# mpstat - statistiques CPU
mpstat
mpstat -P ALL                   # Tous CPU
mpstat 5                        # Toutes les 5 sec

# sar - rapport système (nécessite sysstat)
sar                             # CPU usage
sar -r                          # Mémoire
sar -b                          # I/O
sar -n DEV                      # Network
sar -q                          # Load average

# dmesg - messages kernel
dmesg
dmesg | tail
dmesg | grep -i error
dmesg -T                        # Avec timestamps lisibles
dmesg -w                        # Watch mode
dmesg -l err                    # Seulement erreurs

# === INFORMATIONS SYSTÈME ===

# uname - info système
uname -a                        # Tout
uname -r                        # Version kernel
uname -m                        # Architecture
uname -n                        # Hostname
uname -s                        # Nom système

# hostname - nom machine
hostname
hostname -f                     # FQDN
hostname -i                     # Adresse IP

# lscpu - info CPU
lscpu

# lsmem - info mémoire
lsmem

# lsblk - info disques
lsblk
lsblk -f                        # Avec filesystem
lsblk -o NAME,SIZE,TYPE,MOUNTPOINT

# lspci - périphériques PCI
lspci
lspci -v                        # Verbose
lspci | grep -i vga             # Carte graphique

# lsusb - périphériques USB
lsusb
lsusb -v

# dmidecode - info hardware (nécessite root)
sudo dmidecode
sudo dmidecode -t memory        # Info mémoire
sudo dmidecode -t processor     # Info CPU
sudo dmidecode -t bios          # Info BIOS

# hwinfo - info hardware complète
hwinfo --short

# inxi - info système (nécessite installation)
inxi -F                         # Full info
inxi -b                         # Basic info


[OK] RÉSEAU

# === CONFIGURATION RÉSEAU ===

# ip - outil moderne (remplace ifconfig)
ip addr                         # Adresses IP
ip a                            # Raccourci
ip addr show eth0               # Interface spécifique
ip link                         # Interfaces réseau
ip link show
ip route                        # Table de routage
ip route show
ip neigh                        # ARP table

# Ajouter/supprimer IP
sudo ip addr add 192.168.1.100/24 dev eth0
sudo ip addr del 192.168.1.100/24 dev eth0

# Activer/désactiver interface
sudo ip link set eth0 up
sudo ip link set eth0 down

# ifconfig - outil traditionnel
ifconfig
ifconfig eth0
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0
sudo ifconfig eth0 up
sudo ifconfig eth0 down

# === CONNECTIVITÉ ===

# ping - tester connectivité
ping google.com
ping -c 4 google.com            # 4 pings seulement
ping -i 2 google.com            # Intervalle 2 secondes
ping -s 1000 google.com         # Taille packet 1000 bytes
ping -W 2 google.com            # Timeout 2 secondes

# traceroute - tracer route
traceroute google.com
traceroute -n google.com        # Sans résolution DNS
traceroute -m 15 google.com     # Max 15 hops

# mtr - traceroute continu
mtr google.com
mtr -r -c 10 google.com         # Rapport 10 cycles

# === DNS ===

# nslookup - requête DNS
nslookup google.com
nslookup google.com 8.8.8.8     # Serveur DNS spécifique

# dig - requête DNS avancée
dig google.com
dig google.com +short           # Résultat court
dig google.com MX               # Enregistrements MX
dig google.com NS               # Serveurs de noms
dig @8.8.8.8 google.com         # Serveur DNS spécifique
dig -x 8.8.8.8                  # Reverse lookup

# host - simple lookup
host google.com
host -t MX google.com

# === CONNEXIONS RÉSEAU ===

# netstat - statistiques réseau (ancien)
netstat -tuln                   # Ports en écoute
netstat -tunap                  # Toutes connexions avec PID
netstat -r                      # Table de routage
netstat -i                      # Interfaces
netstat -s                      # Statistiques

# Options:
# -t: TCP
# -u: UDP
# -l: listening
# -n: numérique (pas de résolution)
# -a: all
# -p: PID/program

# ss - socket statistics (moderne, remplace netstat)
ss -tuln                        # Ports en écoute
ss -tunap                       # Toutes connexions
ss -s                           # Statistiques
ss -o                           # Timers
ss -e                           # Détails socket
ss -m                           # Mémoire
ss dst 192.168.1.100            # Destination spécifique
ss sport = :80                  # Port source
ss dport = :443                 # Port destination

# lsof - list open files (inclus sockets)
sudo lsof -i                    # Toutes connexions
sudo lsof -i :80                # Port spécifique
sudo lsof -i TCP                # Seulement TCP
sudo lsof -i UDP                # Seulement UDP
sudo lsof -u username           # Par utilisateur
sudo lsof -c processname        # Par processus

# === TÉLÉCHARGEMENT ===

# wget - télécharger fichiers
wget URL
wget -O filename URL            # Sauver avec nom spécifique
wget -c URL                     # Continuer téléchargement
wget -b URL                     # Arrière-plan
wget -r URL                     # Récursif (site entier)
wget --limit-rate=200k URL      # Limiter vitesse
wget -i urls.txt                # Liste d'URLs
wget --user=username --password=pass URL
wget -q URL                     # Quiet mode

# curl - transfert de données
curl URL
curl -o filename URL            # Sauver dans fichier
curl -O URL                     # Garder nom original
curl -L URL                     # Suivre redirections
curl -C - URL                   # Continuer téléchargement
curl -I URL                     # Headers seulement
curl -X POST URL                # POST request
curl -d "data" URL              # Avec données
curl -H "Header: value" URL     # Header personnalisé
curl -u user:pass URL           # Authentification
curl -s URL                     # Silent mode
curl -v URL                     # Verbose

# Tester API
curl -X GET https://api.example.com/users
curl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' URL

# === FIREWALL ===

# iptables - firewall (traditionnel)
sudo iptables -L                # Lister règles
sudo iptables -L -n             # Sans résolution DNS
sudo iptables -L -v             # Verbose
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT
sudo iptables -D INPUT 5        # Supprimer règle 5
sudo iptables -F                # Flush toutes règles
sudo iptables-save > rules.txt  # Sauvegarder
sudo iptables-restore < rules.txt

# ufw - uncomplicated firewall (Ubuntu)
sudo ufw status
sudo ufw enable
sudo ufw disable
sudo ufw allow 80
sudo ufw allow 80/tcp
sudo ufw allow from 192.168.1.0/24
sudo ufw deny 23
sudo ufw delete allow 80
sudo ufw reset

# firewalld - firewall (RHEL/CentOS)
sudo firewall-cmd --state
sudo firewall-cmd --list-all
sudo firewall-cmd --add-port=80/tcp
sudo firewall-cmd --add-service=http
sudo firewall-cmd --remove-port=80/tcp
sudo firewall-cmd --reload
sudo firewall-cmd --permanent --add-port=80/tcp

# === SSH ===

# Connexion SSH
ssh user@host
ssh -p 2222 user@host           # Port non-standard
ssh -i ~/.ssh/key.pem user@host # Clé privée spécifique
ssh user@host command           # Exécuter commande distante

# Copier fichiers via SSH
scp file.txt user@host:/path/
scp user@host:/path/file.txt .
scp -r dir/ user@host:/path/    # Récursif
scp -P 2222 file.txt user@host:/path/  # Port non-standard

# rsync via SSH (meilleur que scp)
rsync -avz -e ssh file.txt user@host:/path/
rsync -avz -e "ssh -p 2222" dir/ user@host:/path/

# Générer clés SSH
ssh-keygen                      # RSA par défaut
ssh-keygen -t ed25519           # ED25519 (recommandé)
ssh-keygen -t rsa -b 4096       # RSA 4096 bits
ssh-keygen -t ed25519 -C "email@example.com"

# Copier clé publique vers serveur
ssh-copy-id user@host
ssh-copy-id -i ~/.ssh/key.pub user@host

# Config SSH (~/.ssh/config)
# Host myserver
#     HostName 192.168.1.100
#     User myuser
#     Port 2222
#     IdentityFile ~/.ssh/mykey
# Puis: ssh myserver

# SSH tunnels
ssh -L 8080:localhost:80 user@host      # Local port forwarding
ssh -R 8080:localhost:80 user@host      # Remote port forwarding
ssh -D 1080 user@host                   # Dynamic (SOCKS proxy)

# Maintenir connexion SSH
ssh -o ServerAliveInterval=60 user@host

# === ANALYSE RÉSEAU ===

# tcpdump - capturer packets
sudo tcpdump
sudo tcpdump -i eth0            # Interface spécifique
sudo tcpdump -c 100             # 100 packets
sudo tcpdump -w capture.pcap    # Sauver dans fichier
sudo tcpdump -r capture.pcap    # Lire depuis fichier
sudo tcpdump port 80
sudo tcpdump host 192.168.1.100
sudo tcpdump src 192.168.1.100
sudo tcpdump dst 192.168.1.100
sudo tcpdump tcp
sudo tcpdump udp
sudo tcpdump -n                 # Sans résolution DNS
sudo tcpdump -A                 # ASCII
sudo tcpdump -X                 # Hex et ASCII

# wireshark - GUI pour analyse (nécessite X)
wireshark

# nmap - scan réseau
nmap 192.168.1.100              # Scan basique
nmap -p 80,443 192.168.1.100    # Ports spécifiques
nmap -p 1-1000 192.168.1.100    # Range de ports
nmap -sV 192.168.1.100          # Détecter versions services
nmap -O 192.168.1.100           # Détecter OS
nmap -A 192.168.1.100           # Scan agressif
nmap 192.168.1.0/24             # Scan subnet

# nc (netcat) - couteau suisse réseau
nc -l 1234                      # Écouter sur port 1234
nc host 1234                    # Se connecter
nc -zv host 80                  # Tester port
nc -zv host 1-1000              # Scanner ports
echo "GET / HTTP/1.0" | nc host 80

# iperf - tester bande passante
iperf -s                        # Mode serveur
iperf -c server_ip              # Mode client


[OK] DISQUES & SYSTÈMES DE FICHIERS

# === ESPACE DISQUE ===

# df - disk free
df                              # Espace disque
df -h                           # Human readable
df -T                           # Avec type filesystem
df -i                           # Inodes
df -t ext4                      # Seulement type spécifique
df /path                        # Pour point de montage spécifique

# du - disk usage
du                              # Usage répertoire courant
du -h                           # Human readable
du -s                           # Summary (total seulement)
du -sh *                        # Total par élément
du -sh dir/                     # Total d'un répertoire
du -h --max-depth=1             # Profondeur 1
du -h --max-depth=1 | sort -hr  # Trié par taille
du -ah                          # Inclure fichiers
du -c dir1/ dir2/               # Total cumulé

# Trouver gros fichiers/dossiers
du -ah /path | sort -rh | head -20
du -h --max-depth=1 / 2>/dev/null | sort -rh | head -10

# ncdu - du interactif (nécessite installation)
ncdu /path

# === MONTAGE FILESYSTEMS ===

# mount - monter filesystem
mount                           # Lister montages
mount | column -t               # Formaté
sudo mount /dev/sdb1 /mnt
sudo mount -t ext4 /dev/sdb1 /mnt
sudo mount -o ro /dev/sdb1 /mnt # Read-only
sudo mount -o remount,rw /mnt   # Remonter en read-write

# umount - démonter
sudo umount /mnt
sudo umount /dev/sdb1
sudo umount -f /mnt             # Force
sudo umount -l /mnt             # Lazy (démonte dès que possible)

# /etc/fstab - montages automatiques
# Format: device mountpoint fstype options dump pass
# /dev/sdb1 /data ext4 defaults 0 2
# UUID=xxx /data ext4 defaults 0 2

# Tester fstab
sudo mount -a                   # Monte tous ceux du fstab

# findmnt - arbre de montage
findmnt
findmnt /path
findmnt -t ext4                 # Par type

# === PARTITIONNEMENT ===

# fdisk - gestion partitions (MBR)
sudo fdisk -l                   # Lister disques
sudo fdisk /dev/sdb             # Éditer partitions
# Commandes dans fdisk:
# m: aide
# p: print
# n: nouvelle partition
# d: delete partition
# t: changer type
# w: write changes
# q: quit sans sauver

# parted - gestion partitions (GPT et MBR)
sudo parted -l                  # Lister
sudo parted /dev/sdb
# (parted) print
# (parted) mklabel gpt
# (parted) mkpart primary ext4 0% 100%
# (parted) quit

# gdisk - pour GPT
sudo gdisk -l /dev/sdb
sudo gdisk /dev/sdb

# lsblk - vue d'ensemble
lsblk
lsblk -f                        # Avec filesystems

# blkid - UUID et info
sudo blkid
sudo blkid /dev/sdb1

# === CRÉER FILESYSTEMS ===

# mkfs - créer filesystem
sudo mkfs.ext4 /dev/sdb1
sudo mkfs.xfs /dev/sdb1
sudo mkfs.btrfs /dev/sdb1
sudo mkfs -t ext4 /dev/sdb1     # Alternative

# Options ext4
sudo mkfs.ext4 -L mylabel /dev/sdb1     # Avec label
sudo mkfs.ext4 -m 1 /dev/sdb1           # 1% reserved blocks
sudo mkfs.ext4 -j /dev/sdb1             # Avec journal

# === VÉRIFIER & RÉPARER ===

# fsck - filesystem check
sudo fsck /dev/sdb1
sudo fsck -y /dev/sdb1          # Réparer automatiquement
sudo fsck -n /dev/sdb1          # Dry run
sudo fsck -C /dev/sdb1          # Progress bar

# IMPORTANT: démonter avant fsck!
sudo umount /dev/sdb1
sudo fsck /dev/sdb1

# e2fsck - pour ext2/3/4
sudo e2fsck /dev/sdb1
sudo e2fsck -f /dev/sdb1        # Force check
sudo e2fsck -p /dev/sdb1        # Automatic repair

# === SWAP ===

# Créer swap
sudo mkswap /dev/sdb2
sudo swapon /dev/sdb2
sudo swapon -s                  # Afficher swap actif

# Désactiver swap
sudo swapoff /dev/sdb2
sudo swapoff -a                 # Tous

# Fichier swap
sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# /etc/fstab pour swap permanent
# /swapfile none swap sw 0 0

# === LVM (Logical Volume Manager) ===

# Physical Volumes
sudo pvcreate /dev/sdb1
sudo pvdisplay
sudo pvs

# Volume Groups
sudo vgcreate vg_data /dev/sdb1
sudo vgdisplay
sudo vgs
sudo vgextend vg_data /dev/sdc1

# Logical Volumes
sudo lvcreate -L 10G -n lv_data vg_data
sudo lvcreate -l 100%FREE -n lv_data vg_data
sudo lvdisplay
sudo lvs

# Étendre LV
sudo lvextend -L +5G /dev/vg_data/lv_data
sudo lvextend -l +100%FREE /dev/vg_data/lv_data
sudo resize2fs /dev/vg_data/lv_data  # Resize filesystem

# === RAID ===

# mdadm - gérer RAID logiciel
sudo mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sdb1 /dev/sdc1
sudo mdadm --detail /dev/md0
cat /proc/mdstat
sudo mdadm --stop /dev/md0
sudo mdadm --assemble /dev/md0 /dev/sdb1 /dev/sdc1

# === QUOTAS DISQUE ===

# Activer quotas
# Ajouter usrquota,grpquota dans /etc/fstab
sudo mount -o remount /
sudo quotacheck -cugm /
sudo quotaon /

# Définir quotas
sudo edquota -u username
sudo setquota -u username 100000 110000 0 0 /

# Vérifier quotas
quota
quota -u username
sudo repquota -a


[OK] GESTION UTILISATEURS & GROUPES

# === UTILISATEURS ===

# Créer utilisateur
sudo useradd username
sudo useradd -m username        # Avec home directory
sudo useradd -m -s /bin/bash username
sudo useradd -m -d /custom/home username
sudo useradd -m -G sudo,docker username  # Avec groupes
sudo useradd -m -e 2024-12-31 username   # Date expiration

# adduser - interactif (Debian/Ubuntu)
sudo adduser username

# Modifier utilisateur
sudo usermod -l newname oldname # Renommer
sudo usermod -d /new/home username
sudo usermod -s /bin/zsh username
sudo usermod -L username        # Lock account
sudo usermod -U username        # Unlock account
sudo usermod -aG groupname username  # Ajouter à groupe
sudo usermod -g groupname username   # Changer groupe primaire

# Supprimer utilisateur
sudo userdel username
sudo userdel -r username        # Avec home directory
sudo userdel -f username        # Force

# Mot de passe
sudo passwd username
passwd                          # Changer son propre mot de passe
sudo passwd -l username         # Lock
sudo passwd -u username         # Unlock
sudo passwd -e username         # Forcer changement au prochain login
sudo passwd -d username         # Supprimer mot de passe
sudo passwd -S username         # Status

# Changer shell
chsh
chsh -s /bin/zsh

# Info utilisateurs
id                              # Info user courant
id username
whoami
who                             # Qui est connecté
w                               # Qui fait quoi
users                           # Liste users connectés
last                            # Historique connexions
lastlog                         # Dernière connexion par user

# Fichiers utilisateurs
cat /etc/passwd                 # Liste utilisateurs
cat /etc/shadow                 # Mots de passe (root seulement)
cat /etc/group                  # Groupes

# === GROUPES ===

# Créer groupe
sudo groupadd groupname
sudo groupadd -g 1050 groupname # Avec GID spécifique

# Modifier groupe
sudo groupmod -n newname oldname
sudo groupmod -g 1050 groupname

# Supprimer groupe
sudo groupdel groupname

# Ajouter user à groupe
sudo gpasswd -a username groupname
sudo usermod -aG groupname username

# Retirer user de groupe
sudo gpasswd -d username groupname

# Lister groupes d'un user
groups username
id -nG username

# Lister membres d'un groupe
getent group groupname
grep groupname /etc/group

# === SUDO & PERMISSIONS ===

# Utiliser sudo
sudo command
sudo -u username command        # En tant qu'autre user
sudo -i                         # Shell root interactif
sudo -s                         # Shell avec environnement user
sudo su                         # Devenir root
sudo su - username              # Devenir autre user
sudo !!                         # Répéter dernière commande avec sudo

# Configuration sudo (/etc/sudoers)
sudo visudo                     # Éditer sudoers (safe)

# Syntaxe sudoers:
# username ALL=(ALL:ALL) ALL
# %groupname ALL=(ALL:ALL) ALL
# username ALL=(ALL) NOPASSWD: ALL
# username ALL=(ALL) /bin/systemctl restart nginx

# Tester config sudo
sudo -l                         # Ce que user peut faire
sudo -ll                        # Détaillé

# === SU - SWITCH USER ===

su                              # Devenir root
su -                            # Devenir root avec environnement
su username                     # Devenir autre user
su - username                   # Avec environnement
exit                            # Revenir à user précédent


[OK] SERVICES & SYSTEMD

# === SYSTEMD (système init moderne) ===

# Gérer services
sudo systemctl start service
sudo systemctl stop service
sudo systemctl restart service
sudo systemctl reload service   # Recharger config sans restart
sudo systemctl status service
sudo systemctl enable service   # Démarrage automatique
sudo systemctl disable service
sudo systemctl is-active service
sudo systemctl is-enabled service

# Lister services
systemctl list-units --type=service
systemctl list-units --type=service --state=running
systemctl list-units --type=service --state=failed
systemctl --failed

# Lister tous les unit files
systemctl list-unit-files
systemctl list-unit-files --type=service

# Logs de service
sudo journalctl -u service
sudo journalctl -u service -f   # Follow
sudo journalctl -u service --since today
sudo journalctl -u service --since "2024-01-01"
sudo journalctl -u service --since "1 hour ago"

# Recharger systemd
sudo systemctl daemon-reload

# Targets (runlevels)
systemctl get-default
sudo systemctl set-default multi-user.target
systemctl list-units --type=target

# Système
sudo systemctl reboot
sudo systemctl poweroff
sudo systemctl suspend
sudo systemctl hibernate

# === JOURNALCTL - LOGS SYSTEMD ===

# Voir tous les logs
sudo journalctl

# Filtres temps
sudo journalctl --since "2024-01-01"
sudo journalctl --since yesterday
sudo journalctl --since "1 hour ago"
sudo journalctl --until "2024-01-02"
sudo journalctl --since "10:00" --until "11:00"

# Par boot
sudo journalctl -b              # Boot actuel
sudo journalctl -b -1           # Boot précédent
sudo journalctl --list-boots

# Par priorité
sudo journalctl -p err          # Erreurs seulement
sudo journalctl -p warning      # Warning et plus grave

# Par service/unit
sudo journalctl -u nginx.service
sudo journalctl -u nginx.service -u mysql.service

# Follow
sudo journalctl -f
sudo journalctl -u service -f

# Par processus
sudo journalctl _PID=1234

# Format
sudo journalctl -o json         # JSON
sudo journalctl -o json-pretty
sudo journalctl -o verbose

# Limiter lignes
sudo journalctl -n 50           # 50 dernières lignes
sudo journalctl --no-pager

# Espace disque des logs
sudo journalctl --disk-usage
sudo journalctl --vacuum-time=2weeks
sudo journalctl --vacuum-size=500M

# === SYSTEMCTL AVANCÉ ===

# Créer service custom (/etc/systemd/system/myapp.service)
# [Unit]
# Description=My Application
# After=network.target
#
# [Service]
# Type=simple
# User=myuser
# WorkingDirectory=/opt/myapp
# ExecStart=/usr/bin/python3 /opt/myapp/app.py
# Restart=always
#
# [Install]
# WantedBy=multi-user.target

# Activer et démarrer
sudo systemctl daemon-reload
sudo systemctl enable myapp.service
sudo systemctl start myapp.service

# Éditer service
sudo systemctl edit service     # Override file
sudo systemctl edit --full service  # Éditer file complet

# Dépendances
systemctl list-dependencies service
systemctl list-dependencies --reverse service

# === ANCIENS SYSTÈMES (SYSVINIT) ===

# service command (marche avec systemd aussi)
sudo service nginx start
sudo service nginx stop
sudo service nginx restart
sudo service nginx status

# chkconfig (RHEL/CentOS ancien)
sudo chkconfig nginx on
sudo chkconfig nginx off
sudo chkconfig --list

# update-rc.d (Debian/Ubuntu ancien)
sudo update-rc.d nginx defaults
sudo update-rc.d nginx enable
sudo update-rc.d nginx disable


[OK] GESTION PAQUETS

# === DEBIAN/UBUNTU (APT) ===

# Mettre à jour liste paquets
sudo apt update

# Mettre à jour paquets installés
sudo apt upgrade
sudo apt full-upgrade           # Peut supprimer paquets

# Installer
sudo apt install package
sudo apt install package1 package2
sudo apt install package=version

# Supprimer
sudo apt remove package
sudo apt purge package          # Avec fichiers config
sudo apt autoremove             # Supprimer dépendances inutiles

# Rechercher
apt search keyword
apt-cache search keyword

# Info paquet
apt show package
apt-cache show package
apt-cache policy package        # Versions disponibles

# Lister paquets
apt list --installed
apt list --upgradable
dpkg -l                         # Tous paquets
dpkg -l | grep package

# Fichiers d'un paquet
dpkg -L package                 # Lister fichiers
dpkg -S /path/to/file           # Quel paquet contient ce fichier

# Nettoyer
sudo apt clean                  # Cache complet
sudo apt autoclean              # Vieux paquets seulement
sudo apt autoremove

# Fichiers .deb
sudo dpkg -i package.deb
sudo dpkg -r package
sudo dpkg --configure -a        # Réparer installations cassées
sudo apt --fix-broken install

# Sources (/etc/apt/sources.list)
sudo add-apt-repository ppa:user/repo
sudo add-apt-repository --remove ppa:user/repo

# === REDHAT/CENTOS/FEDORA (YUM/DNF) ===

# DNF (Fedora, RHEL 8+, CentOS 8+)
sudo dnf update                 # Mettre à jour
sudo dnf install package
sudo dnf remove package
sudo dnf search keyword
sudo dnf info package
sudo dnf list installed
sudo dnf list available
sudo dnf provides /path/to/file # Quel paquet fournit ce fichier
sudo dnf clean all
sudo dnf autoremove
sudo dnf upgrade                # Upgrade système

# YUM (RHEL/CentOS 7 et antérieur)
sudo yum update
sudo yum install package
sudo yum remove package
sudo yum search keyword
sudo yum info package
sudo yum list installed
sudo yum provides /path/to/file
sudo yum clean all

# RPM - gestion paquets bas niveau
sudo rpm -ivh package.rpm       # Installer
sudo rpm -Uvh package.rpm       # Upgrade
sudo rpm -e package             # Supprimer
rpm -qa                         # Lister tous paquets
rpm -qa | grep package          # Rechercher
rpm -ql package                 # Fichiers du paquet
rpm -qf /path/to/file           # Quel paquet contient ce fichier
rpm -qi package                 # Info paquet

# Repos
sudo yum repolist
sudo dnf repolist
sudo yum-config-manager --add-repo URL
sudo dnf config-manager --add-repo URL

# === ARCH LINUX (PACMAN) ===

# Mettre à jour système
sudo pacman -Syu

# Installer
sudo pacman -S package
sudo pacman -S package1 package2

# Supprimer
sudo pacman -R package
sudo pacman -Rs package         # Avec dépendances
sudo pacman -Rns package        # Avec dépendances et config

# Rechercher
pacman -Ss keyword
pacman -Qs keyword              # Dans paquets installés

# Info
pacman -Si package              # Repo
pacman -Qi package              # Installé

# Lister
pacman -Q                       # Tous installés
pacman -Qe                      # Explicitement installés
pacman -Qdt                     # Orphelins

# Fichiers
pacman -Ql package              # Lister fichiers
pacman -Qo /path/to/file        # Quel paquet contient

# Nettoyer cache
sudo pacman -Sc
sudo pacman -Scc                # Tout le cache

# AUR (Arch User Repository)
# Utiliser un AUR helper comme yay ou paru
yay -S package
yay -Syu                        # Mettre à jour tout (AUR inclus)

# === OPENSUSE (ZYPPER) ===

sudo zypper refresh             # Mettre à jour repos
sudo zypper update
sudo zypper install package
sudo zypper remove package
sudo zypper search keyword
sudo zypper info package
sudo zypper list-updates
sudo zypper clean

# === SNAP (UBUNTU ET AUTRES) ===

snap find package
sudo snap install package
sudo snap install package --classic
sudo snap remove package
snap list
sudo snap refresh               # Mettre à jour tous
sudo snap refresh package       # Mettre à jour un paquet
snap info package

# === FLATPAK ===

flatpak search package
flatpak install flathub package
flatpak uninstall package
flatpak list
flatpak update
flatpak run com.example.App

# Ajouter Flathub
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

# === APPIMAGE ===

chmod +x app.AppImage
./app.AppImage

# === COMPILATION DEPUIS SOURCE ===

# Méthode classique (GNU Autotools)
./configure
make
sudo make install
sudo make uninstall             # Si disponible

# Avec préfixe personnalisé
./configure --prefix=/opt/myapp
make
sudo make install

# CMake
mkdir build && cd build
cmake ..
make
sudo make install

# Vérifier dépendances avant compilation
./configure --help              # Options disponibles
sudo apt install build-essential  # Outils compilation Debian/Ubuntu
sudo yum groupinstall "Development Tools"  # RHEL/CentOS


[OK] VARIABLES D'ENVIRONNEMENT & SHELL

# === VARIABLES ===

# Afficher variable
echo $HOME
echo $PATH
echo $USER
echo $SHELL

# Définir variable (session actuelle)
VAR="value"
export VAR="value"              # Disponible pour sous-processus

# Variables importantes:
# $HOME: répertoire home
# $USER: nom utilisateur
# $PATH: chemins exécutables
# $SHELL: shell par défaut
# $PWD: répertoire courant
# $OLDPWD: répertoire précédent
# $LANG: langue système
# $TERM: type terminal

# Afficher toutes variables
printenv
env
set                             # Inclut variables shell

# Afficher PATH lisiblement
echo $PATH | tr ':' '\n'

# Modifier PATH
export PATH=$PATH:/new/path
export PATH=/new/path:$PATH     # Au début

# Définir permanent (ajouter à ~/.bashrc ou ~/.zshrc)
export VAR="value"
export PATH=$PATH:/my/custom/path

# Supprimer variable
unset VAR

# Variables spéciales shell:
# $0: nom du script
# $1, $2, etc.: arguments
# $#: nombre d'arguments
# $@: tous les arguments
# $?: code retour dernière commande
# $: PID du shell
# $!: PID dernier processus background

# === ALIAS ===

# Définir alias
alias ll='ls -lah'
alias la='ls -A'
alias ..='cd ..'
alias ...='cd ../..'
alias grep='grep --color=auto'
alias update='sudo apt update && sudo apt upgrade'

# Lister alias
alias

# Supprimer alias
unalias ll

# Alias permanent (ajouter à ~/.bashrc ou ~/.zshrc)
# Éditer fichier et ajouter vos alias

# Recharger config
source ~/.bashrc
source ~/.zshrc

# === CONFIGURATION SHELL ===

# Fichiers de configuration Bash:
# /etc/profile: système (tous users)
# /etc/bash.bashrc: système Bash
# ~/.bash_profile: user (login shell)
# ~/.bashrc: user (interactive shell)
# ~/.bash_logout: exécuté à la déconnexion

# Fichiers de configuration Zsh:
# /etc/zsh/zshrc: système
# ~/.zshrc: user

# Éditer configuration
nano ~/.bashrc
nano ~/.zshrc

# Recharger après modification
source ~/.bashrc

# === HISTORIQUE COMMANDES ===

# Afficher historique
history
history 20                      # 20 dernières commandes

# Rechercher dans historique
history | grep keyword
Ctrl+R                          # Recherche interactive

# Exécuter depuis historique
!123                            # Commande numéro 123
!!                              # Dernière commande
!$                              # Dernier argument dernière commande
!*                              # Tous arguments dernière commande
!ssh                            # Dernière commande commençant par ssh

# Configurer historique (~/.bashrc)
export HISTSIZE=10000           # Nombre en mémoire
export HISTFILESIZE=20000       # Nombre dans fichier
export HISTCONTROL=ignoredups   # Ignorer doublons
export HISTIGNORE="ls:cd:pwd"   # Ignorer commandes

# Nettoyer historique
history -c                      # Effacer session
rm ~/.bash_history              # Effacer fichier

# === SCRIPTS SHELL ===

# Créer script
nano script.sh

# Shebang (première ligne)
#!/bin/bash
#!/usr/bin/env bash             # Plus portable

# Exemple script:
#!/bin/bash
echo "Hello World"
VAR="test"
echo "Variable: $VAR"

# Rendre exécutable
chmod +x script.sh

# Exécuter
./script.sh
bash script.sh

# Arguments
# $0: nom script
# $1, $2: arguments
echo "Script: $0"
echo "Argument 1: $1"
echo "Nombre d'arguments: $#"

# Conditions
if [ "$VAR" = "value" ]; then
    echo "Match"
elif [ "$VAR" = "other" ]; then
    echo "Other"
else
    echo "No match"
fi

# Tests courants:
# -f file: fichier existe
# -d dir: répertoire existe
# -r file: readable
# -w file: writable
# -x file: executable
# -z "$var": variable vide
# -n "$var": variable non vide
# "$a" = "$b": égalité strings
# "$a" != "$b": différence strings
# $a -eq $b: égalité nombres
# $a -ne $b: différence nombres
# $a -gt $b: plus grand
# $a -lt $b: plus petit

# Boucles
for i in 1 2 3 4 5; do
    echo $i
done

for file in *.txt; do
    echo "Processing $file"
done

while [ condition ]; do
    echo "Running"
    sleep 1
done

# Fonctions
function myfunction() {
    echo "Argument: $1"
    return 0
}

myfunction "test"

# === REDIRECTIONS ===

# Sortie standard (stdout)
command > file                  # Écraser
command >> file                 # Ajouter
command 1> file                 # Explicite

# Erreur standard (stderr)
command 2> error.log
command 2>> error.log

# Les deux
command > output.log 2>&1
command &> output.log           # Raccourci Bash
command > output.log 2> error.log

# Entrée standard (stdin)
command < input.txt

# Here document
cat << EOF > file.txt
Line 1
Line 2
EOF

# Here string
command <<< "string"

# Supprimer sortie
command > /dev/null             # Stdout
command 2> /dev/null            # Stderr
command &> /dev/null            # Tout

# Tee - afficher et sauver
command | tee output.txt
command | tee -a output.txt     # Append

# === PIPES ===

# Pipe basique
command1 | command2
command1 | command2 | command3

# Exemples utiles
ls -l | grep ".txt"
cat file.txt | wc -l
ps aux | grep nginx
dmesg | tail -20
history | grep ssh
find . -type f | wc -l

# xargs - construire commandes depuis stdin
find . -name "*.log" | xargs rm
ls *.txt | xargs -I {} mv {} /dest/
echo "file1 file2 file3" | xargs -n 1 echo

# === OPÉRATEURS ===

# Exécution séquentielle
command1 ; command2             # Toujours exécuter command2

# Exécution conditionnelle
command1 && command2            # command2 si command1 réussit
command1 || command2            # command2 si command1 échoue

# Exemples
mkdir dir && cd dir
cd /path || exit 1
make && make install || echo "Failed"

# Background
command &                       # Exécuter en arrière-plan
command1 & command2 &           # Plusieurs en parallèle

# Grouper commandes
(command1; command2)            # Sous-shell
{ command1; command2; }         # Shell actuel

# === EXPANSION ===

# Brace expansion
echo {1..10}                    # 1 2 3 4 5 6 7 8 9 10
echo {a..z}                     # a b c ... z
echo file{1,2,3}.txt            # file1.txt file2.txt file3.txt
mkdir -p dir/{sub1,sub2,sub3}

# Tilde expansion
~                               # Home directory
~/Documents
~username

# Parameter expansion
${VAR}                          # Valeur de VAR
${VAR:-default}                 # default si VAR vide/unset
${VAR:=default}                 # Assigne default si vide
${VAR:?error message}           # Erreur si vide
${#VAR}                         # Longueur
${VAR#pattern}                  # Supprime pattern début (court)
${VAR##pattern}                 # Supprime pattern début (long)
${VAR%pattern}                  # Supprime pattern fin (court)
${VAR%%pattern}                 # Supprime pattern fin (long)
${VAR/pattern/replacement}      # Remplace première occurrence
${VAR//pattern/replacement}     # Remplace toutes occurrences

# Command substitution
$(command)                      # Résultat de command
`command`                       # Ancien style
VAR=$(ls -l)

# Arithmetic expansion
$((expression))
echo $((5 + 3))                 # 8
echo $((10 * 2))                # 20
i=$((i + 1))                    # Incrémenter


[OK] CRON & TÂCHES PLANIFIÉES

# === CRON ===

# Éditer crontab utilisateur
crontab -e

# Lister crontab
crontab -l

# Supprimer crontab
crontab -r

# Crontab d'un autre user (root)
sudo crontab -u username -e
sudo crontab -u username -l

# Format crontab:
# * * * * * command
# │ │ │ │ │
# │ │ │ │ └─── Jour de semaine (0-7, 0 et 7 = dimanche)
# │ │ │ └───── Mois (1-12)
# │ │ └─────── Jour du mois (1-31)
# │ └───────── Heure (0-23)
# └─────────── Minute (0-59)

# Exemples:
# Tous les jours à 2h30
30 2 * * * /path/to/script.sh

# Toutes les heures
0 * * * * command

# Toutes les 5 minutes
*/5 * * * * command

# Tous les lundis à 9h
0 9 * * 1 command

# Premier jour du mois à minuit
0 0 1 * * command

# Du lundi au vendredi à 18h
0 18 * * 1-5 command

# Plusieurs fois
0 8,12,18 * * * command         # 8h, 12h et 18h

# Variables dans crontab
SHELL=/bin/bash
PATH=/usr/local/bin:/usr/bin:/bin
MAILTO=user@example.com
HOME=/home/user

0 2 * * * /backup.sh

# Redirection sortie
0 2 * * * /script.sh > /tmp/output.log 2>&1
0 2 * * * /script.sh >> /tmp/output.log 2>&1

# Cron système (/etc/crontab)
# Format: minute heure jour mois jour_semaine user command
0 2 * * * root /backup.sh

# Répertoires cron (Debian/Ubuntu)
# /etc/cron.daily/     # Quotidien
# /etc/cron.hourly/    # Toutes les heures
# /etc/cron.weekly/    # Hebdomadaire
# /etc/cron.monthly/   # Mensuel

# Ajouter script dans ces dossiers (sans extension!)
sudo nano /etc/cron.daily/backup
sudo chmod +x /etc/cron.daily/backup

# Service cron
sudo systemctl status cron      # Debian/Ubuntu
sudo systemctl status crond     # RHEL/CentOS
sudo systemctl restart cron

# Logs cron
sudo grep CRON /var/log/syslog  # Debian/Ubuntu
sudo tail -f /var/log/cron      # RHEL/CentOS
sudo journalctl -u cron

# === AT - TÂCHE UNIQUE ===

# Planifier tâche
at 10:00
at> /path/to/script.sh
at> Ctrl+D

at now + 5 minutes
at 2:30 PM tomorrow
at 10:00 AM 2024-12-25

# Lister tâches
atq
at -l

# Voir détails
at -c job_number

# Supprimer tâche
atrm job_number
at -r job_number

# Depuis fichier
at -f script.sh now + 1 hour

# Service at
sudo systemctl status atd
sudo systemctl start atd

# === SYSTEMD TIMERS ===

# Alternative moderne à cron
# Créer timer (/etc/systemd/system/mytask.timer)
# [Unit]
# Description=My Task Timer
#
# [Timer]
# OnCalendar=daily
# Persistent=true
#
# [Install]
# WantedBy=timers.target

# Créer service (/etc/systemd/system/mytask.service)
# [Unit]
# Description=My Task
#
# [Service]
# Type=oneshot
# ExecStart=/path/to/script.sh

# Activer
sudo systemctl daemon-reload
sudo systemctl enable mytask.timer
sudo systemctl start mytask.timer

# Voir timers
systemctl list-timers
systemctl list-timers --all

# OnCalendar exemples:
# hourly, daily, weekly, monthly, yearly
# *-*-* 02:30:00          # Quotidien à 2h30
# Mon *-*-* 09:00:00      # Lundis à 9h
# *-*-01 00:00:00         # Premier du mois


[OK] LOGS & DEBUGGING

# === FICHIERS LOGS PRINCIPAUX ===

# Debian/Ubuntu
/var/log/syslog                 # Logs système généraux
/var/log/auth.log               # Authentification
/var/log/kern.log               # Kernel
/var/log/boot.log               # Boot
/var/log/dmesg                  # Messages kernel boot
/var/log/apt/                   # APT logs

# RHEL/CentOS
/var/log/messages               # Système général
/var/log/secure                 # Authentification
/var/log/maillog                # Mail
/var/log/cron                   # Cron
/var/log/yum.log                # YUM

# Communs
/var/log/nginx/                 # Nginx
/var/log/apache2/               # Apache
/var/log/mysql/                 # MySQL
/var/log/postgresql/            # PostgreSQL

# === CONSULTER LOGS ===

# Logs système traditionnels
sudo tail -f /var/log/syslog
sudo tail -100 /var/log/auth.log
sudo less /var/log/syslog
sudo cat /var/log/syslog | grep error

# dmesg - messages kernel
dmesg
dmesg | tail
dmesg | grep -i usb
dmesg -w                        # Watch mode
dmesg -T                        # Timestamps lisibles
dmesg -l err,warn               # Erreurs et warnings

# journalctl (déjà couvert dans section SYSTEMD)
sudo journalctl -xe             # Détails récents
sudo journalctl --since today
sudo journalctl -p err
sudo journalctl -u service.service

# === LOGROTATE ===

# Configuration: /etc/logrotate.conf et /etc/logrotate.d/

# Exemple config (/etc/logrotate.d/myapp)
# /var/log/myapp/*.log {
#     daily
#     rotate 7
#     compress
#     delaycompress
#     missingok
#     notifempty
#     create 0640 www-data www-data
#     sharedscripts
#     postrotate
#         systemctl reload myapp
#     endscript
# }

# Tester config
sudo logrotate -d /etc/logrotate.conf

# Forcer rotation
sudo logrotate -f /etc/logrotate.conf

# === RSYSLOG ===

# Config principale: /etc/rsyslog.conf
# Config supplémentaire: /etc/rsyslog.d/

# Exemple règle:
# facility.priority    destination
# *.info               /var/log/info.log
# auth,authpriv.*      /var/log/auth.log
# mail.*               /var/log/mail.log

# Redémarrer rsyslog
sudo systemctl restart rsyslog

# Tester envoi log
logger "Test message"
logger -p user.err "Error message"

# === DEBUGGING SCRIPTS ===

# Activer debug mode
bash -x script.sh
set -x                          # Dans le script
set +x                          # Désactiver

# Options utiles
set -e                          # Arrêter sur erreur
set -u                          # Erreur sur variable undefined
set -o pipefail                 # Erreur dans pipe

# Combiné (début de script)
set -euo pipefail

# Tracer exécution
bash -v script.sh               # Verbose

# === STRACE - TRACER APPELS SYSTÈME ===

# Tracer programme
strace command
strace -o output.txt command
strace -p PID                   # Attacher à processus existant

# Filtrer appels
strace -e open command          # Seulement open
strace -e trace=file command    # Opérations fichiers
strace -e trace=network command # Opérations réseau

# Statistiques
strace -c command

# === LTRACE - TRACER APPELS BIBLIOTHÈQUE ===

ltrace command
ltrace -o output.txt command
ltrace -p PID

# === PERFORMANCE ===

# time - mesurer temps exécution
time command
time -p command                 # Format POSIX

# perf - profiling performance
sudo perf top                   # Top temps réel
sudo perf stat command          # Statistiques
sudo perf record command        # Enregistrer
sudo perf report                # Voir rapport

# === DEBUGGING RÉSEAU ===

# netstat/ss (déjà couvert)
# tcpdump (déjà couvert)

# curl verbose
curl -v URL
curl -I URL                     # Headers seulement

# Test DNS
nslookup domain
dig domain
host domain

# Test port
telnet host port
nc -zv host port


[OK] ARCHIVAGE & BACKUP

# === RSYNC - SYNCHRONISATION ===

# Synchronisation basique
rsync -av source/ dest/
rsync -av /source/ user@host:/dest/

# Options importantes:
# -a: archive mode (récursif, préserve attributs)
# -v: verbose
# -z: compression
# -h: human readable
# -P: progress + partial
# --delete: supprime dans dest si absent de source
# --exclude: exclure patterns
# --dry-run: simulation

# Exemples pratiques
rsync -avz source/ dest/
rsync -avzP source/ user@host:/dest/
rsync -av --delete source/ dest/
rsync -av --exclude='*.log' --exclude='node_modules' source/ dest/
rsync -av --dry-run source/ dest/

# Backup avec hard links (économise espace)
rsync -av --link-dest=/backup/previous /source/ /backup/current/

# Via SSH avec port custom
rsync -av -e "ssh -p 2222" source/ user@host:/dest/

# Limiter bande passante
rsync -av --bwlimit=1000 source/ dest/  # 1000 KB/s

# === DD - COPIE BAS NIVEAU ===

# Copier disque/partition
sudo dd if=/dev/sda of=/dev/sdb bs=4M status=progress
sudo dd if=/dev/sda1 of=/backup/partition.img bs=4M

# Créer image ISO
sudo dd if=/dev/cdrom of=disc.iso bs=4M

# Créer USB bootable
sudo dd if=ubuntu.iso of=/dev/sdb bs=4M status=progress

# Effacer disque
sudo dd if=/dev/zero of=/dev/sdb bs=4M status=progress
sudo dd if=/dev/urandom of=/dev/sdb bs=4M  # Sécurisé

# Backup MBR
sudo dd if=/dev/sda of=mbr_backup.img bs=512 count=1

# Restaurer MBR
sudo dd if=mbr_backup.img of=/dev/sda bs=512 count=1

# === AUTRES OUTILS BACKUP ===

# duplicity - backup incrémental chiffré
duplicity /source file:///backup
duplicity --encrypt-key KEY /source sftp://user@host/backup

# borgbackup - backup dédupliqué
borg init --encryption=repokey /path/to/repo
borg create /path/to/repo::archive-name /source
borg list /path/to/repo
borg extract /path/to/repo::archive-name
borg prune --keep-daily=7 --keep-weekly=4 /path/to/repo

# restic - backup moderne
restic -r /backup init
restic -r /backup backup /source
restic -r /backup snapshots
restic -r /backup restore latest --target /restore

# === SCRIPTS BACKUP ===

# Exemple script backup avec tar
#!/bin/bash
BACKUP_DIR="/backup"
SOURCE="/data"
DATE=$(date +%Y%m%d_%H%M%S)
FILENAME="backup_${DATE}.tar.gz"

tar -czf "${BACKUP_DIR}/${FILENAME}" "${SOURCE}"

# Garder seulement 7 derniers backups
cd "${BACKUP_DIR}"
ls -t backup_*.tar.gz | tail -n +8 | xargs -r rm

# Exemple avec rotation
#!/bin/bash
BACKUP_DIR="/backup"
SOURCE="/data"
DATE=$(date +%Y-%m-%d)

# Backup incrémental avec rsync
rsync -av --link-dest="${BACKUP_DIR}/latest" \
    "${SOURCE}/" "${BACKUP_DIR}/${DATE}/"

# Mettre à jour lien "latest"
rm -f "${BACKUP_DIR}/latest"
ln -s "${DATE}" "${BACKUP_DIR}/latest"


[OK] SÉCURITÉ

# === FIREWALL (déjà couvert en partie) ===

# Voir section RÉSEAU pour iptables, ufw, firewalld

# === FAIL2BAN ===

# Installer
sudo apt install fail2ban

# Configuration
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
sudo nano /etc/fail2ban/jail.local

# Exemple config SSH
# [sshd]
# enabled = true
# port = ssh
# filter = sshd
# logpath = /var/log/auth.log
# maxretry = 3
# bantime = 3600

# Gérer service
sudo systemctl status fail2ban
sudo systemctl restart fail2ban

# Commandes
sudo fail2ban-client status
sudo fail2ban-client status sshd
sudo fail2ban-client set sshd unbanip IP

# === SELINUX (RHEL/CENTOS) ===

# Statut SELinux
getenforce
sestatus

# Modes:
# Enforcing: appliqué
# Permissive: log seulement
# Disabled: désactivé

# Changer mode temporaire
sudo setenforce 0               # Permissive
sudo setenforce 1               # Enforcing

# Changer mode permanent (/etc/selinux/config)
# SELINUX=enforcing|permissive|disabled

# Contextes SELinux
ls -Z file
ps -eZ
id -Z

# Restaurer contextes
sudo restorecon -Rv /path/

# Changer contexte
sudo chcon -t httpd_sys_content_t /var/www/html/file

# Voir logs SELinux
sudo ausearch -m avc -ts recent
sudo grep AVC /var/log/audit/audit.log

# === APPARMOR (UBUNTU) ===

# Statut
sudo aa-status
sudo apparmor_status

# Modes profil:
# enforce: appliqué
# complain: log seulement

# Mettre profil en mode complain
sudo aa-complain /path/to/profile

# Mettre en mode enforce
sudo aa-enforce /path/to/profile

# Désactiver profil
sudo ln -s /etc/apparmor.d/profile /etc/apparmor.d/disable/
sudo apparmor_parser -R /etc/apparmor.d/profile

# Logs
sudo journalctl | grep apparmor
sudo dmesg | grep apparmor

# === CHIFFREMENT ===

# LUKS - chiffrement disque
sudo cryptsetup luksFormat /dev/sdb1
sudo cryptsetup luksOpen /dev/sdb1 encrypted_disk
sudo mkfs.ext4 /dev/mapper/encrypted_disk
sudo mount /dev/mapper/encrypted_disk /mnt

# Fermer volume chiffré
sudo umount /mnt
sudo cryptsetup luksClose encrypted_disk

# GPG - chiffrement fichiers
# Générer clé
gpg --full-generate-key

# Lister clés
gpg --list-keys
gpg --list-secret-keys

# Chiffrer fichier
gpg -e -r email@example.com file.txt
gpg --encrypt --recipient email@example.com file.txt

# Déchiffrer
gpg -d file.txt.gpg > file.txt
gpg --decrypt file.txt.gpg

# Signer fichier
gpg --sign file.txt

# Chiffrer symétrique (mot de passe)
gpg -c file.txt
gpg --symmetric file.txt

# === AUDIT SÉCURITÉ ===

# lynis - audit sécurité système
sudo lynis audit system

# chkrootkit - détecter rootkits
sudo chkrootkit

# rkhunter - détecter rootkits
sudo rkhunter --check

# ClamAV - antivirus
sudo apt install clamav
sudo freshclam                  # Mettre à jour signatures
sudo clamscan -r /path
sudo clamscan -r --infected /path

# === PERMISSIONS AVANCÉES ===

# Déjà couvert dans section PERMISSIONS
# Voir: chmod, chown, ACL, attributs

# === LIMITES RESSOURCES ===

# ulimit - limites shell
ulimit -a                       # Voir toutes limites
ulimit -n                       # Nombre fichiers ouverts
ulimit -n 4096                  # Définir limite
ulimit -u                       # Nombre processus
ulimit -m                       # Mémoire

# Limites système (/etc/security/limits.conf)
# username soft nofile 4096
# username hard nofile 8192
# @groupname soft nproc 100
# * soft core 0

# Voir limites d'un processus
cat /proc/PID/limits


[OK] PERFORMANCE & /etc/passwd        # Lignes finissant par bash
grep -E '[0-9]{1,3}\.[0-9]{1,3}' file  # IP addresses
grep -P '\d{4}-\d{2}-\d{2}' file  # Dates YYYY-MM-DD

# === JQ - PARSER JSON ===

# Basique
cat file.json | jq .
jq '.' file.json

# Extraire champs
jq '.field' file.json
jq '.field.subfield' file.json
jq '.array[]' file.json         # Tous éléments array
jq '.array[0]' file.json        # Premier élément

# Filtres
jq '.[] | select(.age > 18)' file.json
jq '.[] | select(.name == "John")' file.json

# Map
jq 'map(.name)' file.json
jq '.[] | .name' file.json

# Construire objet
jq '{name: .name, age: .age}' file.json

# === YQ - PARSER YAML ===

yq eval '.field' file.yaml
yq eval '.array[]' file.yaml
yq eval '.field = "new value"' file.yaml


[OK] AUTOMATISATION & SCRIPTING AVANCÉ

# === BASH AVANCÉ ===

# Arrays
arr=(one two three)
echo ${arr[0]}                  # Premier élément
echo ${arr[@]}                  # Tous éléments
echo ${#arr[@]}                 # Nombre éléments
arr+=(four)                     # Ajouter élément

# Associative arrays (Bash 4+)
declare -A dict
dict[key1]="value1"
dict[key2]="value2"
echo ${dict[key1]}
echo ${!dict[@]}                # Toutes les clés

# Fonctions avancées
function myfunc() {
    local var="local"           # Variable locale
    echo "Args: $@"
    return 0
}

# Gérer options
while getopts "a:b:c" opt; do
    case $opt in
        a) arg_a=$OPTARG ;;
        b) arg_b=$OPTARG ;;
        c) flag_c=true ;;
        \?) echo "Invalid option" ;;
    esac
done

# Trap - gérer signaux
trap 'echo "Cleaning up..."; rm -f /tmp/file' EXIT
trap 'echo "Interrupted"; exit 1' INT TERM

# Lecture input
read -p "Enter name: " name
read -s -p "Password: " password  # Silent
read -t 10 -p "Quick: " answer    # Timeout 10 sec

# Here document avec variables
cat <<EOF > file.txt
User: $USER
Date: $(date)
EOF

# Process substitution
diff <(ls dir1) <(ls dir2)
while read line; do echo $line; done < <(command)

# === PYTHON SCRIPTING ===

# One-liners Python
python3 -c "print('Hello')"
python3 -c "import sys; print(sys.version)"

# HTTP server simple
python3 -m http.server 8000
python3 -m http.server --directory /path 8080

# JSON pretty print
cat file.json | python3 -m json.tool

# === AWK AVANCÉ ===

# Variables internes:
# NR: numéro ligne
# NF: nombre de champs
# FS: field separator
# RS: record separator

# BEGIN et END
awk 'BEGIN {print "Start"} {print} END {print "End"}' file

# Conditions
awk '$3 > 100 {print $1, $3}' file
awk '$1 == "root" {print}' /etc/passwd

# Calculs
awk '{sum += $1} END {print sum}' file
awk '{sum += $1} END {print sum/NR}' file  # Moyenne

# Multiples délimiteurs
awk -F'[,:]' '{print $1, $2}' file

# Printf formatage
awk '{printf "%-10s %5d\n", $1, $2}' file

# === EXPECT - AUTOMATISER INTERACTIONS ===

#!/usr/bin/expect
spawn ssh user@host
expect "password:"
send "mypassword\r"
expect "$"
send "ls -la\r"
expect "$"
send "exit\r"
interact

# === ANSIBLE - AUTOMATISATION ===

# Playbook exemple (site.yml)
# ---
# - hosts: webservers
#   tasks:
#     - name: Install nginx
#       apt:
#         name: nginx
#         state: present
#     - name: Start nginx
#       service:
#         name: nginx
#         state: started

# Exécuter playbook
ansible-playbook site.yml

# Commande ad-hoc
ansible all -m ping
ansible webservers -m shell -a "uptime"


[OK] DÉPANNAGE & PROBLÈMES COURANTS

# === SYSTÈME NE BOOT PAS ===

# Mode recovery/rescue
# Au boot: choisir recovery mode dans GRUB
# Ou ajouter: init=/bin/bash

# Réparer GRUB
sudo grub-install /dev/sda
sudo update-grub

# fsck sur root (en rescue mode)
fsck -y /dev/sda1

# === ESPACE DISQUE PLEIN ===

# Trouver gros fichiers
du -ah / | sort -rh | head -20
find / -type f -size +100M 2>/dev/null
find / -type f -size +1G -exec ls -lh {} \; 2>/dev/null

# Nettoyer
sudo apt clean
sudo journalctl --vacuum-time=7d
sudo journalctl --vacuum-size=500M
find /var/log -name "*.gz" -delete
find /tmp -type f -atime +7 -delete

# === SYSTÈME LENT ===

# Vérifier load average
uptime
top

# Processus consommant CPU
ps aux --sort=-%cpu | head
top -o %CPU

# Processus consommant mémoire
ps aux --sort=-%mem | head
top -o %MEM

# I/O wait élevé
iostat -x 5
iotop -o

# === RÉSEAU NE FONCTIONNE PAS ===

# Vérifier interface
ip link show
ip addr show

# Activer interface
sudo ip link set eth0 up

# Vérifier route
ip route show
ping -c 4 8.8.8.8
ping -c 4 google.com

# DNS
cat /etc/resolv.conf
nslookup google.com

# Tester connectivité
curl -v https://google.com
telnet google.com 80

# === IMPOSSIBLE DE SE CONNECTER SSH ===

# Vérifier service
sudo systemctl status sshd
sudo systemctl restart sshd

# Vérifier port
sudo ss -tulnp | grep :22
sudo netstat -tulnp | grep :22

# Logs
sudo tail -f /var/log/auth.log
sudo journalctl -u sshd -f

# Permissions
ls -la ~/.ssh/
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

# === PROCESSUS ZOMBIE ===

# Trouver zombies
ps aux | grep Z
ps aux | awk '$8=="Z"'

# Trouver parent
ps -o ppid= -p PID

# Kill parent
kill -9 PPID

# === PERMISSIONS DENIED ===

# Vérifier permissions
ls -l file
ls -ld dir

# Vérifier propriétaire
ls -l file
sudo chown user:group file

# SELinux/AppArmor
getenforce
sudo setenforce 0
sudo aa-status

# === COMMANDES UTILES DIAGNOSTIC ===

# Info système complète
sudo dmidecode
lshw
inxi -F

# Température CPU
sensors
watch -n 2 sensors

# Batterie (laptops)
upower -i /org/freedesktop/UPower/devices/battery_BAT0
acpi -V


[OK] ASTUCES & BONNES PRATIQUES

# === PRODUCTIVITÉ ===

# Historique recherche reverse
Ctrl+R                          # Puis taper

# Bang commands
!!                              # Dernière commande
!$                              # Dernier argument
!^                              # Premier argument
!*                              # Tous arguments
!ssh                            # Dernière commande ssh
^old^new                        # Substitution rapide

# Raccourcis terminal
Ctrl+A                          # Début ligne
Ctrl+E                          # Fin ligne
Ctrl+U                          # Effacer jusqu'au début
Ctrl+K                          # Effacer jusqu'à la fin
Ctrl+W                          # Effacer mot
Ctrl+L                          # Clear screen
Ctrl+C                          # Interrompre
Ctrl+Z                          # Suspendre
Ctrl+D                          # EOF / logout

# Auto-complétion
Tab                             # Compléter
Tab Tab                         # Lister options

# === ALIAS UTILES ===

alias ll='ls -lah'
alias la='ls -A'
alias l='ls -CF'
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias grep='grep --color=auto'
alias df='df -h'
alias du='du -h'
alias free='free -h'
alias ps='ps auxf'
alias psgrep='ps aux | grep -v grep | grep -i -e VSZ -e'
alias mkdir='mkdir -pv'
alias wget='wget -c'
alias h='history'
alias j='jobs -l'
alias now='date +"%T"'
alias nowdate='date +"%d-%m-%Y"'

# Sécurité
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'

# Git
alias gs='git status'
alias ga='git add'
alias gc='git commit'
alias gp='git push'
alias gl='git log --oneline'

# === FONCTIONS UTILES ===

# Créer et entrer dans dossier
mkcd() {
    mkdir -p "$1" && cd "$1"
}

# Extraire archives
extract() {
    if [ -f $1 ]; then
        case $1 in
            *.tar.bz2)   tar xjf $1     ;;
            *.tar.gz)    tar xzf $1     ;;
            *.bz2)       bunzip2 $1     ;;
            *.rar)       unrar e $1     ;;
            *.gz)        gunzip $1      ;;
            *.tar)       tar xf $1      ;;
            *.tbz2)      tar xjf $1     ;;
            *.tgz)       tar xzf $1     ;;
            *.zip)       unzip $1       ;;
            *.Z)         uncompress $1  ;;
            *.7z)        7z x $1        ;;
            *)     echo "'$1' cannot be extracted" ;;
        esac
    else
        echo "'$1' is not a valid file"
    fi
}

# Backup rapide
backup() {
    cp "$1"{,.bak-$(date +%Y%m%d-%H%M%S)}
}

# === SÉCURITÉ ===

# Toujours utiliser sudo au lieu de root
# Ne jamais exécuter rm -rf / ou similaire
# Vérifier commandes avant exécution
# Faire des backups réguliers
# Tester en environnement de dev d'abord
# Lire la documentation (man pages)
# Double-check permissions avant chmod 777
# Ne pas stocker mots de passe en clair
# Utiliser SSH keys au lieu de passwords
# Garder système à jour

# === PERFORMANCE ===

# Utiliser & pour background tasks
# Utiliser nohup pour processus persistants
# Utiliser screen/tmux pour sessions persistantes
# Pipes sont plus efficaces que fichiers temporaires
# Préférer grep -F pour strings littéraux
# Utiliser find -exec + au lieu de xargs quand possible
# Désactiver SELinux/AppArmor seulement si vraiment nécessaire

# === DOCUMENTATION ===

# man pages
man command
man -k keyword                  # Rechercher
man 5 passwd                    # Section spécifique

# info pages
info command

# Help intégré
command --help
command -h

# tldr - exemples pratiques
tldr command

# apropos - rechercher commandes
apropos keyword

# whatis - description courte
whatis command


[OK] OUTILS MODERNES & ALTERNATIVES

# === ALTERNATIVES MODERNES ===

# cat -> bat (syntax highlighting)
bat file.txt

# ls -> exa, lsd
exa -la
lsd -la

# find -> fd
fd pattern
fd -e txt

# grep -> ripgrep (rg)
rg pattern
rg -i pattern

# du -> dust, ncdu
dust
ncdu

# top/htop -> btop, glances
btop
glances

# ps -> procs
procs

# df -> duf
duf

# sed/awk -> sd, miller
sd 'old' 'new' file.txt

# diff -> delta
delta file1 file2

# man -> tldr
tldr command

# curl -> httpie
http GET https://api.github.com

# ping -> gping
gping google.com


[OK] RESSOURCES & APPRENTISSAGE

# === DOCUMENTATION ===

# Man pages: man command
# Info pages: info command
# Help: command --help

# Sites web:
# - Linux Documentation Project: tldp.org
# - ArchWiki: wiki.archlinux.org (excellente doc)
# - Ubuntu Help: help.ubuntu.com
# - RHEL Docs: access.redhat.com/documentation

# === PRATIQUE ===

# Environnements de test:
# - VirtualBox, VMware
# - Docker containers
# - Cloud providers (AWS, GCP, Azure free tier)
# - OverTheWire wargames (pratique sécurité)

# === CERTIFICATIONS ===

# - Linux Foundation Certified System Administrator (LFCS)
# - Linux Foundation Certified Engineer (LFCE)
# - Red Hat Certified System Administrator (RHCSA)
# - Red Hat Certified Engineer (RHCE)
# - CompTIA Linux+

# === COMMANDES À CONNAÎTRE ===

# Essentielles (priorité 1):
# ls, cd, pwd, mkdir, rmdir, rm, cp, mv, touch
# cat, less, head, tail, grep, find
# chmod, chown, sudo, su
# ps, top, kill, killall
# df, du, free
# ssh, scp, rsync
# man, --help

# Importantes (priorité 2):
# tar, gzip, zip, unzip
# wget, curl
# nano, vi/vim
# ln, readlink
# wc, sort, uniq, cut, sed, awk
# diff, patch
# mount, umount
# systemctl, journalctl
# apt/yum/dnf (selon distro)

# Avancées (priorité 3):
# strace, ltrace, lsof
# netstat, ss, ip, tcpdump
# cron, at
# iptables, ufw
# lvm, mdadm
# xargs, parallel
# screen, tmux
# git (non couvert ici mais essentiel)


[OK] SCREEN & TMUX - MULTIPLEXEURS TERMINAUX

# === SCREEN ===

# Démarrer session
screen
screen -S session_name

# Commandes (préfixe: Ctrl+a)
Ctrl+a c                        # Nouvelle fenêtre
Ctrl+a n                        # Fenêtre suivante
Ctrl+a p                        # Fenêtre précédente
Ctrl+a "                        # Liste fenêtres
Ctrl+a 0-9                      # Aller à fenêtre N
Ctrl+a d                        # Détacher session
Ctrl+a k                        # Tuer fenêtre
Ctrl+a S                        # Split horizontal
Ctrl+a |                        # Split vertical
Ctrl+a Tab                      # Changer split
Ctrl+a X                        # Fermer split
Ctrl+a ?                        # Aide

# Gérer sessions
screen -ls                      # Lister sessions
screen -r                       # Réattacher dernière
screen -r session_name          # Réattacher session
screen -r PID                   # Réattacher par PID
screen -d -r session_name       # Détacher puis réattacher
screen -X -S session_name quit  # Tuer session

# Scroll mode
Ctrl+a [                        # Entrer mode copy
Espace                          # Début sélection
Entrée                          # Fin sélection / copier
Ctrl+a ]                        # Coller

# Configuration (~/.screenrc)
# startup_message off
# defscrollback 10000
# hardstatus alwayslastline "%{= kw}%-w%{= BW}%n %t%{-}%+w %-= %{= kw}%H | %l | %Y-%m-%d %c"

# === TMUX ===

# Démarrer session
tmux
tmux new -s session_name

# Commandes (préfixe: Ctrl+b)
Ctrl+b c                        # Nouvelle fenêtre
Ctrl+b n                        # Fenêtre suivante
Ctrl+b p                        # Fenêtre précédente
Ctrl+b w                        # Liste fenêtres
Ctrl+b 0-9                      # Aller à fenêtre N
Ctrl+b ,                        # Renommer fenêtre
Ctrl+b d                        # Détacher session
Ctrl+b &                        # Tuer fenêtre
Ctrl+b %                        # Split vertical
Ctrl+b "                        # Split horizontal
Ctrl+b o                        # Changer pane
Ctrl+b x                        # Fermer pane
Ctrl+b z                        # Zoom pane
Ctrl+b [                        # Mode scroll
Ctrl+b ]                        # Coller
Ctrl+b ?                        # Aide

# Navigation panes avec flèches
Ctrl+b <-^->v                     # Changer pane

# Gérer sessions
tmux ls                         # Lister sessions
tmux attach                     # Réattacher dernière
tmux attach -t session_name     # Réattacher session
tmux kill-session -t session_name
tmux kill-server                # Tuer toutes sessions

# Dans tmux
Ctrl+b s                        # Liste sessions
Ctrl+b $                        # Renommer session
Ctrl+b (                        # Session précédente
Ctrl+b )                        # Session suivante

# Configuration (~/.tmux.conf)
# set -g mouse on
# set -g history-limit 10000
# set -g base-index 1
# setw -g pane-base-index 1
# bind r source-file ~/.tmux.conf \; display "Reloaded!"

# Recharger config
tmux source-file ~/.tmux.conf
# Ou dans tmux: Ctrl+b : puis source-file ~/.tmux.conf

# Copier mode
# Entrer en mode copie: Ctrl+b [
# Déplacer avec vi keys ou flèches
# Espace pour commencer sélection
# Entrée pour copier
# Ctrl+b ] pour coller

# Partager session (utilisateurs multiples)
tmux -S /tmp/shared new -s shared
chmod 777 /tmp/shared
# Autre user:
tmux -S /tmp/shared attach -t shared


[OK] GIT ESSENTIALS (BONUS)

# === GIT BASIQUE ===

# Configuration initiale
git config --global user.name "Your Name"
git config --global user.email "email@example.com"
git config --global core.editor vim
git config --list

# Créer repo
git init
git clone https://github.com/user/repo.git
git clone https://github.com/user/repo.git mydir

# Status et info
git status
git status -s                   # Court
git log
git log --oneline
git log --graph --oneline --all
git diff
git diff --staged
git show commit_hash

# Ajouter et committer
git add file.txt
git add .
git add -A
git commit -m "Message"
git commit -am "Message"        # Add + commit fichiers modifiés

# Branches
git branch                      # Lister branches
git branch new_branch           # Créer branche
git checkout branch_name        # Changer branche
git checkout -b new_branch      # Créer et changer
git switch branch_name          # Moderne (Git 2.23+)
git switch -c new_branch        # Créer et changer
git merge branch_name           # Merger branche
git branch -d branch_name       # Supprimer branche

# Remote
git remote -v
git remote add origin URL
git push origin main
git push -u origin main         # Set upstream
git pull origin main
git fetch origin

# Annuler changements
git checkout -- file.txt        # Annuler modifications
git restore file.txt            # Moderne
git reset HEAD file.txt         # Unstage
git restore --staged file.txt   # Moderne
git reset --hard                # DANGER: annuler tout
git revert commit_hash          # Revert commit
git clean -fd                   # Supprimer untracked

# Stash
git stash                       # Sauver changements
git stash list
git stash pop                   # Appliquer et supprimer
git stash apply                 # Appliquer sans supprimer
git stash drop

# Tags
git tag v1.0.0
git tag -a v1.0.0 -m "Version 1.0.0"
git push origin v1.0.0
git push --tags

# .gitignore
# *.log
# node_modules/
# .env
# __pycache__/


[OK] SURVEILLANCE & MONITORING

# === NAGIOS / ICINGA ===

# Monitoring open-source professionnel
# Installation et configuration spécifique à chaque distro

# === ZABBIX ===

# Monitoring et alerting
# Supporte agents et monitoring sans agent (SNMP, IPMI, etc.)

# === PROMETHEUS & GRAFANA ===

# Stack moderne monitoring
# Prometheus: collecte métriques
# Grafana: visualisation

# === ELK STACK ===

# Elasticsearch + Logstash + Kibana
# Centralisation et analyse logs

# === NETDATA ===

# Monitoring temps réel simple
# Installation
bash <(curl -Ss https://my-netdata.io/kickstart.sh)

# Accès: http://localhost:19999

# === MONIT ===

# Monitoring et restart automatique services
# Config: /etc/monit/monitrc

# Exemple config
# check process nginx with pidfile /var/run/nginx.pid
#   start program = "/usr/bin/systemctl start nginx"
#   stop program = "/usr/bin/systemctl stop nginx"
#   if failed host localhost port 80 protocol http then restart

# === GLANCES ===

# Monitoring système en CLI
glances
glances -w                      # Web server mode
glances -s                      # Server mode
glances -c @server              # Client mode

# === COMMANDS MONITORING ===

# Watch - répéter commande
watch -n 5 df -h
watch -n 1 'ps aux | grep nginx'
watch -d -n 2 free -h           # Highlight différences

# while loop monitoring
while true; do clear; date; ps aux | grep nginx; sleep 5; done


[OK] BASES DE DONNÉES EN CLI

# === MYSQL / MARIADB ===

# Se connecter
mysql -u root -p
mysql -u user -p database
mysql -h hostname -u user -p

# Commandes SQL de base
SHOW DATABASES;
USE database_name;
SHOW TABLES;
DESCRIBE table_name;
SELECT * FROM table_name;
SELECT * FROM table_name LIMIT 10;

# Backup
mysqldump -u root -p database_name > backup.sql
mysqldump -u root -p --all-databases > all_backup.sql
mysqldump -u root -p database_name table_name > table_backup.sql

# Restore
mysql -u root -p database_name < backup.sql
mysql -u root -p < all_backup.sql

# Créer user et permissions
CREATE USER 'user'@'localhost' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON database.* TO 'user'@'localhost';
FLUSH PRIVILEGES;

# Monitoring
SHOW PROCESSLIST;
SHOW STATUS;
SHOW VARIABLES;

# === POSTGRESQL ===

# Se connecter
psql -U postgres
psql -U user -d database
psql -h hostname -U user -d database

# Commandes psql
\l                              # Lister databases
\c database_name                # Se connecter à database
\dt                             # Lister tables
\d table_name                   # Décrire table
\du                             # Lister users
\q                              # Quitter

# Backup
pg_dump database_name > backup.sql
pg_dump -U user database_name > backup.sql
pg_dumpall > all_backup.sql

# Restore
psql database_name < backup.sql
psql -U user database_name < backup.sql

# === MONGODB ===

# Se connecter
mongo
mongosh                         # Nouvelle version

# Commandes
show dbs
use database_name
show collections
db.collection.find()
db.collection.find().limit(10)
db.collection.find().pretty()

# Backup
mongodump --db database_name
mongodump --out /backup/path

# Restore
mongorestore /backup/path
mongorestore --db database_name /backup/path/database_name

# === REDIS ===

# CLI
redis-cli
redis-cli -h hostname -p port

# Commandes
PING
INFO
KEYS *
GET key
SET key value
DEL key
FLUSHALL                        # DANGER: tout supprimer

# Backup
redis-cli SAVE
# Fichier: dump.rdb

# === SQLITE ===

# CLI
sqlite3 database.db

# Commandes
.databases
.tables
.schema table_name
.quit

# SQL normal
SELECT * FROM table_name;

# Backup
sqlite3 database.db .dump > backup.sql

# Restore
sqlite3 newdb.db < backup.sql


[OK] WEB SERVERS

# === NGINX ===

# Installer
sudo apt install nginx

# Commandes
sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx
sudo systemctl reload nginx     # Sans downtime
sudo systemctl status nginx
sudo nginx -t                   # Test config
sudo nginx -T                   # Dump config

# Fichiers config
# /etc/nginx/nginx.conf          # Config principale
# /etc/nginx/sites-available/    # Sites disponibles
# /etc/nginx/sites-enabled/      # Sites actifs

# Activer site
sudo ln -s /etc/nginx/sites-available/mysite /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

# Logs
tail -f /var/log/nginx/access.log
tail -f /var/log/nginx/error.log

# Exemple config site (/etc/nginx/sites-available/mysite)
# server {
#     listen 80;
#     server_name example.com;
#     root /var/www/mysite;
#     index index.html;
#
#     location / {
#         try_files $uri $uri/ =404;
#     }
# }

# === APACHE ===

# Installer
sudo apt install apache2

# Commandes
sudo systemctl start apache2
sudo systemctl stop apache2
sudo systemctl restart apache2
sudo systemctl reload apache2
sudo systemctl status apache2
sudo apache2ctl configtest      # Test config
sudo apachectl -t               # Alternative

# Fichiers config
# /etc/apache2/apache2.conf      # Config principale
# /etc/apache2/sites-available/  # Sites disponibles
# /etc/apache2/sites-enabled/    # Sites actifs

# Activer site
sudo a2ensite mysite.conf
sudo a2dissite mysite.conf
sudo systemctl reload apache2

# Modules
sudo a2enmod rewrite            # Activer module
sudo a2dismod rewrite           # Désactiver
sudo apache2ctl -M              # Lister modules

# Logs
tail -f /var/log/apache2/access.log
tail -f /var/log/apache2/error.log


[OK] MAIL & SMTP

# === SENDMAIL / POSTFIX ===

# Envoyer mail simple
echo "Body" | mail -s "Subject" user@example.com
echo "Body" | sendmail user@example.com

# Avec mailx
echo "Message body" | mailx -s "Subject" -r from@example.com to@example.com

# === MAIL QUEUE ===

# Postfix
mailq                           # Voir queue
postqueue -p                    # Voir queue
postsuper -d ALL                # Vider queue
postsuper -d queue_id           # Supprimer message
postqueue -f                    # Forcer envoi

# Logs
tail -f /var/log/mail.log
tail -f /var/log/maillog

# === TESTER SMTP ===

# telnet
telnet smtp.example.com 25
# > EHLO localhost
# > MAIL FROM:<sender@example.com>
# > RCPT TO:<recipient@example.com>
# > DATA
# > Subject: Test
# > 
# > Test message
# > .
# > QUIT

# nc (netcat)
nc smtp.example.com 25

# swaks - Swiss Army Knife SMTP
swaks --to user@example.com --from sender@example.com --server smtp.example.com


[OK] CERTIFICATS SSL/TLS

# === OPENSSL ===

# Générer clé privée
openssl genrsa -out private.key 2048
openssl genrsa -out private.key 4096

# Générer CSR (Certificate Signing Request)
openssl req -new -key private.key -out request.csr

# Générer certificat auto-signé
openssl req -x509 -new -nodes -key private.key -days 365 -out certificate.crt

# Tout en une commande
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

# Voir certificat
openssl x509 -in certificate.crt -text -noout
openssl x509 -in certificate.crt -noout -dates

# Vérifier certificat
openssl verify certificate.crt

# Tester connexion SSL
openssl s_client -connect example.com:443
openssl s_client -connect example.com:443 -showcerts

# Voir dates expiration
echo | openssl s_client -connect example.com:443 2>/dev/null | openssl x509 -noout -dates

# Convertir formats
openssl x509 -in cert.crt -outform PEM -out cert.pem
openssl x509 -in cert.pem -outform DER -out cert.der

# === LET'S ENCRYPT (CERTBOT) ===

# Installer
sudo apt install certbot
sudo apt install python3-certbot-nginx  # Plugin Nginx

# Obtenir certificat
sudo certbot certonly --standalone -d example.com
sudo certbot --nginx -d example.com     # Auto-config Nginx
sudo certbot --apache -d example.com    # Auto-config Apache

# Renouveler
sudo certbot renew
sudo certbot renew --dry-run            # Test

# Lister certificats
sudo certbot certificates

# Révoquer
sudo certbot revoke --cert-path /etc/letsencrypt/live/example.com/cert.pem

# Auto-renouvellement (cron/systemd)
sudo systemctl status certbot.timer     # Vérifie timer
# Ou ajouter à cron:
# 0 3 * * * certbot renew --quiet


Voici **5 grands énoncés d’exercices détaillés** pour la section **Certificats SSL/TLS**, adaptés à une installation Linux récente avec peu de fichiers et utilisateurs :

---

# [BLEU] **EXERCICE 1 — Génération de clés et certificats auto-signés avec OpenSSL**

## **Énoncé détaillé**

1. Créez un répertoire `ssl_test` pour stocker vos certificats :

   ```bash
   mkdir ~/ssl_test && cd ~/ssl_test
   ```
2. Générez une **clé privée RSA** de 2048 bits et de 4096 bits :

   ```bash
   openssl genrsa -out private_2048.key 2048
   openssl genrsa -out private_4096.key 4096
   ```
3. Créez un **CSR (Certificate Signing Request)** à partir de la clé 2048 bits :

   ```bash
   openssl req -new -key private_2048.key -out request.csr
   ```

   * Remplissez les informations demandées (Pays, Organisation, Common Name…).
4. Générez un **certificat auto-signé** valide 365 jours :

   ```bash
   openssl req -x509 -new -nodes -key private_2048.key -days 365 -out certificate.crt
   ```
5. Vérifiez le certificat généré en affichant ses détails :

   ```bash
   openssl x509 -in certificate.crt -text -noout
   openssl x509 -in certificate.crt -noout -dates
   ```

---

# [BLEU] **EXERCICE 2 — Vérification et tests SSL**

## **Énoncé détaillé**

1. Vérifiez la validité de votre certificat local :

   ```bash
   openssl verify certificate.crt
   ```
2. Testez une connexion SSL sur un serveur externe (exemple : `google.com`) :

   ```bash
   openssl s_client -connect google.com:443
   openssl s_client -connect google.com:443 -showcerts
   ```
3. Affichez uniquement les dates d’expiration d’un certificat distant :

   ```bash
   echo | openssl s_client -connect google.com:443 2>/dev/null | openssl x509 -noout -dates
   ```
4. Convertissez votre certificat entre formats PEM et DER :

   ```bash
   openssl x509 -in certificate.crt -outform PEM -out cert.pem
   openssl x509 -in cert.pem -outform DER -out cert.der
   ```
5. Comparez les formats et notez la différence entre **PEM (texte lisible)** et **DER (binaire)**.

---

# [BLEU] **EXERCICE 3 — Gestion des certificats avec Let's Encrypt (Certbot)**

## **Énoncé détaillé**

1. Installez Certbot et le plugin Nginx :

   ```bash
   sudo apt install certbot python3-certbot-nginx
   ```
2. Obtenez un certificat pour un domaine test (remplacez `example.com` par votre domaine) :

   ```bash
   sudo certbot certonly --standalone -d example.com
   ```

   * Vérifiez que le certificat est créé dans `/etc/letsencrypt/live/example.com/`.
3. Configurez automatiquement Nginx pour utiliser le certificat :

   ```bash
   sudo certbot --nginx -d example.com
   ```
4. Testez la **connexion HTTPS** sur votre serveur local pour vérifier que le certificat est actif.
5. Listez tous les certificats actifs sur le système :

   ```bash
   sudo certbot certificates
   ```

---

# [BLEU] **EXERCICE 4 — Renouvellement et révoquation de certificats**

## **Énoncé détaillé**

1. Testez le renouvellement d’un certificat sans réellement le modifier (mode dry-run) :

   ```bash
   sudo certbot renew --dry-run
   ```
2. Renouvelez manuellement un certificat existant :

   ```bash
   sudo certbot renew
   ```
3. Révoquez un certificat pour le supprimer de l’infrastructure :

   ```bash
   sudo certbot revoke --cert-path /etc/letsencrypt/live/example.com/cert.pem
   ```
4. Vérifiez les logs de renouvellement pour comprendre le processus et détecter les erreurs :

   ```bash
   sudo systemctl status certbot.timer
   ```
5. Ajoutez une **tâche cron** pour le renouvellement automatique tous les jours à 3h :

   ```bash
   0 3 * * * certbot renew --quiet
   ```

---

# [BLEU] **EXERCICE 5 — Sécurisation et bonnes pratiques SSL/TLS**

## **Énoncé détaillé**

1. Comparez les clés RSA 2048 et 4096 bits et notez les différences en termes de sécurité et taille.
2. Testez la génération d’un certificat **tout-en-un** :

   ```bash
   openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes
   ```
3. Analysez le certificat avec OpenSSL pour vérifier la signature et les dates.
4. Configurez un serveur local Nginx ou Apache pour utiliser votre certificat auto-signé et testez HTTPS dans un navigateur.
5. Documentez le chemin complet du certificat, de la clé privée et du CSR, ainsi que la procédure de renouvellement automatique avec Certbot.

---


[OK] COMMANDES AVANCÉES & TRICKS

# === PARALLEL PROCESSING ===

# GNU Parallel
parallel echo ::: A B C D
parallel -j 4 command ::: input1 input2 input3
parallel gzip ::: *.txt
find . -name "*.log" | parallel gzip

# xargs parallèle
find . -name "*.txt" | xargs -P 4 -I {} command {}
ls *.jpg | xargs -P 8 -I {} convert {} {}.png

# === ONE-LINERS PUISSANTS ===

# Top 10 commandes utilisées
history | awk '{print $2}' | sort | uniq -c | sort -rn | head -10

# Trouver fichiers dupliqués
find . -type f -exec md5sum {} + | sort | uniq -w32 -dD

# Générer mot de passe aléatoire
openssl rand -base64 32
tr -dc A-Za-z0-9 </dev/urandom | head -c 32

# Vérifier ports ouverts sur machine distante
for port in {1..1000}; do timeout 1 bash -c "echo >/dev/tcp/host/$port" && echo "$port open"; done 2>/dev/null

# Surveiller changements fichier
watch -d cat file.txt

# Télécharger site web complet
wget --mirror --convert-links --adjust-extension --page-requisites --no-parent https://example.com

# Créer tunnel SSH
ssh -L local_port:remote_host:remote_port user@ssh_server

# Partager répertoire via HTTP rapidement
python3 -m http.server 8000

# Comparer répertoires
diff -qr dir1/ dir2/

# Renommer multiple fichiers
for f in *.txt; do mv "$f" "${f%.txt}.bak"; done
rename 's/\.txt$/.bak/' *.txt

# === CALCULS EN LIGNE DE COMMANDE ===

# bc - calculatrice
echo "scale=2; 10/3" | bc
bc <<< "scale=4; sqrt(2)"

# Convertir bases
echo "ibase=16; FF" | bc        # Hex vers decimal
echo "obase=16; 255" | bc       # Decimal vers hex
echo "obase=2; 255" | bc        # Decimal vers binaire

# calc (si installé)
calc "2^10"

# === ENCODAGE / DÉCODAGE ===

# Base64
echo "text" | base64
echo "dGV4dAo=" | base64 -d

# URL encoding
echo "hello world" | jq -sRr @uri
python3 -c "import urllib.parse; print(urllib.parse.quote('hello world'))"

# Hex encoding
echo "text" | xxd -p
echo "74657874" | xxd -r -p

# === HACHAGE ===

# MD5
echo -n "text" | md5sum
md5sum file.txt

# SHA256
echo -n "text" | sha256sum
sha256sum file.txt

# Vérifier checksum
sha256sum -c checksums.txt

# === GÉNÉRATION DONNÉES ===

# Générer fichier de taille spécifique
dd if=/dev/zero of=file.bin bs=1M count=100    # 100MB zéros
dd if=/dev/urandom of=file.bin bs=1M count=100 # 100MB aléatoire
fallocate -l 1G file.bin                       # 1GB rapide

# yes - répéter texte
yes | command                   # Répondre "y" automatiquement
yes "text" | head -n 1000

# seq - séquence nombres
seq 1 10
seq 1 2 10                      # Pas de 2
seq -w 1 100                    # Avec zéros (01, 02, etc.)

# === MANIPULATION DATES ===

# Date actuelle
date
date +%Y-%m-%d
date +%Y-%m-%d_%H-%M-%S
date +%s                        # Unix timestamp

# Date spécifique
date -d "2024-01-01"
date -d "next monday"
date -d "2 days ago"
date -d "1 week ago"
date -d "+1 month"

# Convertir timestamp
date -d @1704067200

# Différence entre dates
echo $(( ($(date -d "2024-12-31" +%s) - $(date +%s)) / 86400 )) days


[OK] TROUBLESHOOTING AVANCÉ

# === STRACE AVANCÉ ===

# Tracer fichiers ouverts
strace -e open,openat command

# Tracer network
strace -e socket,connect,sendto,recvfrom command

# Statistiques temps
strace -c command

# Suivre forks
strace -f command

# Output détaillé
strace -s 1000 command          # Strings jusqu'à 1000 chars

# === LSOF AVANCÉ ===

# Fichiers ouverts par processus
lsof -p PID

# Processus utilisant fichier/répertoire
lsof /path/to/file
lsof +D /path/to/dir

# Fichiers réseau
lsof -i                         # Tous
lsof -i :80                     # Port spécifique
lsof -i TCP:80-443              # Range
lsof -i @192.168.1.1            # Host spécifique

# Utilisateur spécifique
lsof -u username
lsof -u ^username               # Tous sauf username

# Fichiers supprimés mais toujours ouverts
lsof | grep deleted

# === DEBUGGING KERNEL ===

# sysrq - Magic keys (si activé)
# Alt+SysRq+lettre

# Sync disks
echo s | sudo tee /proc/sysrq-trigger

# Remount read-only
echo u | sudo tee /proc/sysrq-trigger

# Reboot immédiat
echo b | sudo tee /proc/sysrq-trigger

# Kill tous processus
echo i | sudo tee /proc/sysrq-trigger

# Liste complète
echo h | sudo tee /proc/sysrq-trigger

# === RÉCUPÉRATION DONNÉES ===

# testdisk - récupérer partitions
sudo testdisk

# photorec - récupérer fichiers
sudo photorec

# dd_rescue - copier avec erreurs
dd_rescue /dev/sda1 /backup/disk.img

# foremost - récupérer fichiers effacés
sudo foremost -t all -i /dev/sda1 -o /recovery

# extundelete - récupérer sur ext3/ext4
sudo extundelete /dev/sda1 --restore-all


[OK] SYNTAXE & RAPPELS RAPIDES

# === TESTS CONDITIONS ===

# Fichiers/Répertoires:
-e file    # Existe
-f file    # Fichier régulier
-d file    # Répertoire
-L file    # Lien symbolique
-r file    # Readable
-w file    # Writable
-x file    # Executable
-s file    # Non vide
-nt file   # Newer than
-ot file   # Older than

# Strings:
-z str     # Vide
-n str     # Non vide
str1 = str2
str1 != str2
str1 < str2
str1 > str2

# Nombres:
-eq        # Égal
-ne        # Différent
-lt        # Less than
-le        # Less or equal
-gt        # Greater than
-ge        # Greater or equal

# Logique:
!          # NOT
-a         # AND
-o         # OR

# === REDIRECTIONS RAPPEL ===

>          # Redirige stdout (écrase)
>>         # Redirige stdout (append)
2>         # Redirige stderr
2>>        # Redirige stderr (append)
&>         # Redirige stdout et stderr
2>&1       # Redirige stderr vers stdout
<          # Input depuis fichier
<<EOF      # Here document
<<<        # Here string
|          # Pipe
|&         # Pipe stdout et stderr

# === EXPANSION RAPPEL ===

~          # Home
*          # Wildcard (tous)
?          # Wildcard (un caractère)
[abc]      # Un de a, b, ou c
{a,b,c}    # Brace expansion
{1..10}    # Range expansion
$var       # Variable
$(cmd)     # Command substitution
$((expr))  # Arithmetic expansion


[OK] FIN DU CHEATSHEET

# Ce cheatsheet couvre:
# [OK] Navigation & fichiers
# [OK] Recherche & manipulation texte
# [OK] Permissions & propriété
# [OK] Processus & système
# [OK] Réseau & connectivité
# [OK] Disques & filesystems
# [OK] Utilisateurs & groupes
# [OK] Services & systemd
# [OK] Gestion paquets
# [OK] Variables & shell
# [OK] Cron & tâches planifiées
# [OK] Logs & debugging
# [OK] Archivage & backup
# [OK] Sécurité
# [OK] Performance
# [OK] Conteneurs
# [OK] Screen & tmux
# [OK] Web servers
# [OK] Bases de données
# [OK] SSL/TLS
# [OK] Et bien plus!

# Pour aller plus loin:
# - Pratiquez régulièrement
# - Lisez les man pages
# - Explorez les options avancées
# - Automatisez avec scripts
# - Contribuez aux projets open-source

# Bon apprentissage Linux! 
