Guide d'étude LFCS : Déploiement et Opérations

Ce document est basé sur le programme LFCS, couvrant les compétences essentielles pour le déploiement, la gestion et la maintenance d'un système Linux.

Section 1 – Commandes de Base (Introduction)

Cette section est inspirée par l'introduction aux commandes Linux de Stéphane Robert.

Objectifs Pédagogiques

  • Se familiariser avec la navigation dans l'arborescence des fichiers.
  • Maîtriser la création, la suppression, la copie et le déplacement de fichiers et de répertoires.
  • Savoir afficher le contenu des fichiers de manière sécurisée.

Concepts et Commandes Clés

1. Navigation dans les répertoires

  • pwd: (Print Working Directory) Affiche le chemin complet du répertoire où vous vous trouvez.
  • cd [chemin]: (Change Directory) Change de répertoire.
    • cd /var/log: Va au répertoire `/var/log` (chemin absolu).
    • cd ..: Remonte au répertoire parent.
    • cd ~ ou `cd`: Retourne à votre répertoire personnel.
    • cd -: Retourne au répertoire précédent.
  • ls [options]: (List) Liste le contenu d'un répertoire.
    • ls -l: Affiche un format "long" (permissions, propriétaire, taille...).
    • ls -a: Affiche "tous" (all) les fichiers, y compris les fichiers cachés (commençant par un `.`).
    • ls -lh: Format long et "humainement" lisible (taille en Ko, Mo, Go).

2. Gestion des fichiers et répertoires

  • mkdir [nom]: (Make Directory) Crée un nouveau répertoire.
  • mkdir -p A/B/C: Crée les répertoires parents (`-p`) s'ils n'existent pas.
  • rmdir [nom]: (Remove Directory) Supprime un répertoire *vide*.
  • touch [fichier]: Crée un fichier vide ou met à jour sa date de modification.
  • cp [source] [destination]: (Copy) Copie un fichier ou un répertoire.
  • cp -r [dossier] [destination]: Copie un répertoire de manière récursive.
  • mv [source] [destination]: (Move) Déplace un fichier/répertoire, ou le renomme.
  • rm [fichier]: (Remove) Supprime un fichier. Attention, il n'y a pas de corbeille !
  • rm -r [dossier]: Supprime un répertoire et tout son contenu (récursif). À utiliser avec une extrême prudence.

3. Consultation de fichiers

  • cat [fichier]: (Concatenate) Affiche le contenu *complet* d'un fichier. Mauvaise idée pour les gros fichiers.
  • less [fichier]: Affiche le contenu d'un fichier page par page (permet de naviguer avec les flèches, `q` pour quitter). C'est la méthode la plus sûre.
  • head [fichier]: Affiche les 10 premières lignes.
  • tail [fichier]: Affiche les 10 dernières lignes.
  • tail -f [fichier]: Affiche la fin du fichier et suit les ajouts en temps réel (très utile pour les logs).

Exemples d'application

  • Lister les fichiers de log : ls -lh /var/log
  • Créer une arborescence de projet : mkdir -p ~/projets/site_web/images
  • Faire une copie de sauvegarde d'un fichier de configuration : sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
  • Renommer un fichier : mv rapport_v1.txt rapport_final.txt
  • Consulter un fichier de log : less /var/log/syslog

Section 2 – Commandes Avancées

Cette section s'inspire des thèmes avancés pour les administrateurs système.

Objectifs Pédagogiques

  • Maîtriser la recherche de fichiers avec `find`.
  • Filtrer et manipuler des flux de texte avec `grep`, `awk` et `sed`.
  • Gérer les utilisateurs, les groupes et les permissions `sudo`.
  • Diagnostiquer les problèmes réseau de base.
  • Gérer les permissions fines avec les ACLs (Access Control Lists).

Concepts et Commandes Clés

1. Recherche Avancée (`find`, `grep`)

  • find /etc -name "*.conf": Trouve tous les fichiers se terminant par `.conf` dans `/etc`.
  • find / -type f -mtime -7: Trouve les fichiers (`-type f`) modifiés il y a moins de 7 jours (`-mtime -7`).
  • find / -type f -size +100M: Trouve les fichiers de plus de 100 Mo.
  • grep -r "192.168.1.1" /etc/: Recherche récursivement la chaîne "192.168.1.1" dans `/etc`.

2. Manipulation de Texte (`sed`, `awk`)

  • sed 's/ancien/nouveau/g' fichier.txt: Remplace "ancien" par "nouveau" dans un fichier.
  • awk '{print $1}' fichier.txt: Affiche uniquement la première colonne (séparée par des espaces) d'un fichier.
  • ls -l | awk '$5 > 1024': (Pipe) N'affiche que les fichiers (`ls -l`) dont la 5ème colonne (taille) est supérieure à 1024.

3. Gestion des Utilisateurs et `sudo`

  • sudo useradd -m -s /bin/bash nom_user: Ajoute un utilisateur, crée son `/home` (`-m`) et définit son shell.
  • sudo usermod -aG sudo nom_user: Ajoute l'utilisateur au groupe `sudo` (`-aG` pour Append to Group).
  • sudo userdel -r nom_user: Supprime l'utilisateur et son répertoire personnel (`-r`).
  • sudo visudo: Ouvre l'éditeur sécurisé pour le fichier `/etc/sudoers`.

4. Permissions Avancées (ACL)

Les ACLs (Access Control Lists) permettent de donner des permissions à des utilisateurs spécifiques sans les ajouter au groupe propriétaire.

  • getfacl fichier.txt: Affiche les permissions ACL d'un fichier.
  • setfacl -m u:bob:rw fichier.txt: Donne à l'utilisateur `bob` les droits `rw` sur le fichier.
  • setfacl -x u:bob fichier.txt: Supprime les permissions ACL pour `bob`.

5. Outils Réseau (`ip`, `ss`)

Ces commandes remplacent les anciens `ifconfig` et `netstat`.

  • ip addr show (ou `ip a`): Affiche les adresses IP.
  • ip route show (ou `ip r`): Affiche la table de routage.
  • ss -tunlp: Affiche les sockets (`-t` TCP, `-u` UDP, `-n` numérique, `-l` listening, `-p` processus).

Exemples d'application

  • Afficher les ports ouverts : sudo ss -tunlp
  • Trouver tous les fichiers de plus de 50Mo dans `/home` : find /home -type f -size +50M
  • Extraire les utilisateurs du fichier passwd : cat /etc/passwd | awk -F: '{print $1}' (Utilise `-F:` pour définir le délimiteur à `:`).
  • Donner à 'alice' l'accès à un dossier projet : sudo setfacl -m u:alice:rwx /srv/projet/

Section 3 – Redémarrage et arrêt du système

Objectifs Pédagogiques

  • Comprendre la différence entre un arrêt immédiat et un arrêt planifié.
  • Maîtriser les commandes `systemctl` pour la gestion moderne de l'alimentation.
  • Savoir utiliser `shutdown` pour planifier des arrêts en toute sécurité et avertir les utilisateurs.
  • Gérer les annulations et les redémarrages forcés.

Concepts et Commandes Clés

1. La méthode moderne : `systemctl`

Depuis l'avènement de `systemd`, les commandes `systemctl` sont le moyen privilégié pour un contrôle direct et immédiat de l'état du système. Elles sont directes et n'envoient pas d'avertissement aux utilisateurs.

  • systemctl reboot: Redémarre le système immédiatement.
  • systemctl poweroff: Éteint le système et coupe l'alimentation.
  • systemctl halt: Arrête le système mais ne coupe pas nécessairement l'alimentation (moins courant aujourd'hui).

2. La méthode traditionnelle et planifiée : `shutdown`

La commande `shutdown` est la méthode la plus sûre pour un serveur en production. Elle permet de planifier l'arrêt et, surtout, d'envoyer un message "wall" (un message à tous les terminaux) pour avertir les utilisateurs connectés de sauvegarder leur travail.

  • shutdown [OPTIONS] TEMPS [MESSAGE]: Syntaxe de base.
  • shutdown -r 02:00: Planifie un redémarrage (reboot) à 2h00 du matin.
  • shutdown -h +15: Planifie un arrêt (halt/poweroff) dans 15 minutes.
  • sudo shutdown -r +1 'Redémarrage planifié pour mise à jour kernel': Planifie un redémarrage dans 1 minute et envoie le message à tous les utilisateurs.
  • shutdown -c: Cancelle un `shutdown` planifié.
  • shutdown now: Équivalent de `systemctl poweroff` (mais envoie quand même un avertissement).

Exemples d'application

  • Planifier un redémarrage dans 10 minutes : sudo shutdown -r +10 "Mise à jour du noyau"
  • Arrêt immédiat (méthode moderne) : sudo systemctl poweroff
  • Annuler un arrêt ou redémarrage planifié : sudo shutdown -c

Section 4 – Gestion des journaux et surveillance

Objectifs Pédagogiques

  • Comprendre la différence entre les logs `rsyslog` (texte) et le `journald` (binaire).
  • Savoir interroger le journal `systemd` avec `journalctl`.
  • Filtrer les journaux par service, priorité (gravité) et plage horaire.
  • Utiliser les commandes `last` et `lastlog` pour l'audit des connexions.

Concepts et Commandes Clés

1. `rsyslog` vs `journald`

`rsyslog` (et `syslog-ng`) : C'est le système de logging traditionnel. Il écrit des messages en texte brut dans des fichiers, généralement dans `/var/log/` (ex: `/var/log/syslog`, `/var/log/auth.log`). Il est facile à lire avec `cat`, `grep`, `tail`.
`journald` (de `systemd`) : C'est le système de logging moderne. Il capture les logs de `systemd`, du noyau, et des services dans un journal binaire, structuré et centralisé (généralement dans `/run/log/journal/` ou `/var/log/journal/`). On ne peut le lire qu'avec `journalctl`.

2. Interroger avec `journalctl`

`journalctl` est l'outil puissant pour filtrer le journal binaire.

  • journalctl: Affiche tout le journal (le plus récent en bas).
  • journalctl -r: Affiche en ordre reverse (le plus récent en haut).
  • journalctl -f: Suit les logs en temps réel (follow).
  • journalctl -u ssh.service: Filtre par unité (service).
  • journalctl -p err: Filtre par priorité. `err` (ou `3`) affiche les niveaux `err`, `crit`, `alert`, `emerg`.
  • journalctl -S "01:00" -U "02:00": Filtre par plage horaire (Since, Until).
  • journalctl -S "1 hour ago": Utilise un temps relatif.
  • journalctl _PID=1234: Filtre par champ (ici, le PID).

3. Logs d'audit : `last` et `lastlog`

Ces commandes lisent des bases de données binaires spéciales pour l'audit des connexions.

  • last: Lit `/var/log/wtmp` pour afficher l'historique de toutes les connexions (utilisateurs, tty, heure de début, heure de fin).
  • lastlog: Lit `/var/log/lastlog` pour afficher la *dernière* connexion de *chaque* utilisateur du système.
  • lastb: (Souvent besoin de `sudo`) Lit `/var/log/btmp` pour afficher les tentatives de connexion bâclées (échouées).

Exemples d'application

  • Suivre les logs en temps réel (comme `tail -f`) : journalctl -f
  • Voir les 20 derniers logs du noyau : journalctl -k -n 20
  • Logs d'erreur du service 'cron' : journalctl -u cron.service -p err
  • Voir les 5 dernières tentatives de connexion échouées : sudo lastb -n 5

Section 5 – Planification des tâches

Objectifs Pédagogiques

  • Comprendre la différence entre `cron` (serveur), `anacron` (desktop) et `at` (tâche unique).
  • Savoir lire et écrire une ligne `crontab`.
  • Gérer les `crontabs` utilisateur (`crontab -e`) et les `crontabs` système (`/etc/cron.d/`).
  • Planifier, visualiser et supprimer des tâches uniques avec `at`.

Concepts et Commandes Clés

1. `cron` : Tâches récurrentes (serveur)

Le démon `cron` se réveille chaque minute et vérifie s'il y a des tâches à exécuter. Il est parfait pour les serveurs qui tournent 24/7. Si le serveur est éteint à l'heure prévue, la tâche est manquée.

Syntaxe Crontab :

# m   h   dom mon dow   commande
# ┬   ┬   ┬   ┬   ┬
# │   │   │   │   │
# │   │   │   │   └─── Jour de la semaine (0-7, 0 et 7=Dimanche)
# │   │   │   └─────── Mois (1-12)
# │   │   └────────── Jour du mois (1-31)
# │   └───────────── Heure (0-23)
# └───────────────── Minute (0-59)
#
# Exemple : Tous les jours à 3h30 du matin
# 30  3   * * * /chemin/vers/script.sh
#
# Exemple : Le 1er de chaque mois à minuit (00:00)
# 0   0   1   * * /bin/backup_database
  • crontab -e: Édite la crontab de l'utilisateur courant (stockée dans `/var/spool/cron/crontabs/`).
  • crontab -l: Liste la crontab de l'utilisateur.
  • /etc/cron.d/, /etc/cron.hourly/, etc. : Répertoires pour les tâches *système*. Les fichiers dans `cron.d` nécessitent un utilisateur (ex: `0 0 * * * root /script`).

2. `anacron` : Tâches récurrentes (desktop)

`anacron` est conçu pour les machines non-serveurs (laptops, desktops). Il vérifie au démarrage si des tâches (`daily`, `weekly`, `monthly`) ont été manquées et les exécute si nécessaire. Il est configuré dans `/etc/anacrontab`.

3. `at` : Tâche unique

La commande `at` est utilisée pour exécuter une commande *une seule fois* dans le futur. Elle dépend du service `atd`.

  • at '15:00' ou `at 'now + 10 minutes'`: Ouvre un prompt interactif. Tapez vos commandes, puis `Ctrl+D` pour valider.
  • echo "reboot" | at '04:00': Planifie une commande non-interactivement.
  • atq: Affiche la file d'attente (`queue`) des tâches `at`.
  • atrm [job_id]: Supprime (`rm`) une tâche `at` de la file.

Exemples d'application

  • Tâche Cron (tous les dimanches à 4h05) : Dans `crontab -e`, ajoutez :
    5 4 * * 0 /root/scripts/backup.sh
  • Planifier un redémarrage ce soir à 22h00 : echo "reboot" | at 22:00
  • Voir les tâches 'at' en attente : atq

Section 6 – Supervision des ressources et intégrité

Objectifs Pédagogiques

  • Différencier `df` (utilisation par partition) et `du` (utilisation par répertoire).
  • Analyser l'utilisation de la mémoire (RAM et Swap) avec `free`.
  • Comprendre la "charge système" (load average) avec `uptime`.
  • Connaître les commandes de vérification d'intégrité (`fsck`, `xfs_repair`) et leurs précautions.

Concepts et Commandes Clés

1. Espace Disque : `df` vs `du`

  • df -h: (Disk Free) Affiche l'utilisation par *système de fichiers* (partition). `-h` pour humainement lisible (Mo, Go). C'est la première commande à taper si on suspecte un disque plein.
  • df -i: Affiche l'utilisation des inodes (un disque peut être "plein" s'il n'y a plus d'inodes, même s'il reste de l'espace).
  • du -sh /usr/: (Disk Usage) Calcule l'espace utilisé par un *répertoire*. `-s` pour summary (total) et `-h` pour humain. `du` est lent car il doit lire tous les sous-dossiers.

2. Mémoire : `free`

  • free -h: Affiche l'état de la RAM et du Swap.
    • total: RAM totale.
    • used: RAM activement utilisée par les programmes.
    • free: RAM totalement inutilisée (ceci est souvent bas sur Linux, c'est normal !).
    • buff/cache: RAM utilisée par le noyau pour le cache disque. C'est de la "bonne" utilisation.
    • available: La "vraie" mémoire disponible pour de nouvelles applications (combine `free` + `cache` récupérable).
    • Swap: Mémoire virtuelle sur le disque dur. Si `used` est élevé, le système est lent.

3. Charge Système : `uptime` et CPU

  • uptime: Affiche le temps de fonctionnement, le nombre d'utilisateurs, et la "load average" (charge moyenne).
    • `load average: 0.10, 0.45, 1.05` : Ce sont les charges moyennes sur 1, 5, et 15 minutes.
    • Interprétation : Sur un système à 1 cœur (CPU), un load de 1.00 signifie 100% d'utilisation. Sur un système à 4 cœurs, un load de 4.00 signifie 100% d'utilisation.
  • lscpu: Liste les informations détaillées sur le(s) CPU (nombre de cœurs, sockets, etc.).

4. Intégrité des systèmes de fichiers

ATTENTION : Ne JAMAIS exécuter `fsck` ou `xfs_repair` sur un système de fichiers monté. Cela causera une corruption massive des données.

  • sudo fsck.ext4 -p /dev/sda1: (File System Check) Pour `ext4`. Doit être exécuté sur une partition démontée. L'option `-p` tente une réparation automatique non-interactive.
  • sudo xfs_repair -v /dev/sdb1: Outil équivalent pour le système de fichiers `XFS`.

Exemples d'application

  • Vérifier l'espace disque (lisible) : df -h
  • Vérifier l'utilisation des inodes : df -i
  • Taille totale du répertoire `/var/log` : sudo du -sh /var/log
  • Mémoire disponible (la vraie) : free -h (Regarder la colonne 'available')
  • Charge CPU et temps de fonctionnement : uptime

Section 7 – Paramètres du noyau (sysctl)

Objectifs Pédagogiques

  • Comprendre que `sysctl` modifie les paramètres du noyau Linux *à chaud* (runtime).
  • Savoir lire et écrire des paramètres temporairement.
  • Savoir rendre un paramètre permanent en créant un fichier `.conf` dans `/etc/sysctl.d/`.

Concepts et Commandes Clés

1. Le système de fichiers `/proc/sys`

Le noyau Linux expose ses paramètres modifiables dans le système de fichiers virtuel `/proc/sys/`. Par exemple, le paramètre `vm.swappiness` (agressivité du swap) est contrôlé par le fichier `/proc/sys/vm/swappiness`.

`sysctl` est simplement une interface plus propre pour lire et écrire dans ces fichiers.

2. Modification temporaire (runtime)

Ces changements sont actifs immédiatement, mais seront perdus au prochain redémarrage.

  • sysctl -a: Affiche tous (all) les paramètres.
  • sysctl vm.swappiness (ou `cat /proc/sys/vm/swappiness`): Lit la valeur actuelle.
  • sudo sysctl -w vm.swappiness=20: Écrit (write) la nouvelle valeur (temporairement).

3. Modification permanente (Persistance)

Au démarrage, `systemd-sysctl.service` lit tous les fichiers `.conf` dans `/etc/sysctl.d/` et applique leur contenu.

  • sudo vim /etc/sysctl.d/99-custom.conf: Crée un fichier de configuration (le `99-` assure qu'il est lu en dernier et écrase les défauts).
  • Contenu du fichier : `vm.swappiness = 20` (Notez la syntaxe : `.` devient `=` et les `/` deviennent `.`).
  • sudo sysctl -p /etc/sysctl.d/99-custom.conf: Applique (pour "load") les paramètres du fichier *maintenant*, sans avoir à redémarrer.

Exemples d'application

  • Autoriser le "forwarding" IP (pour un routeur) : sudo sysctl -w net.ipv4.ip_forward=1
  • Rendre ce paramètre permanent : echo "net.ipv4.ip_forward = 1" | sudo tee /etc/sysctl.d/99-forward.conf
  • Recharger tous les fichiers de conf système : sudo sysctl --system

Section 8 – Sécurité : SELinux

Objectifs Pédagogiques

  • Comprendre la différence entre le Contrôle d'Accès Discrétionnaire (DAC) et Obligatoire (MAC).
  • Comprendre le concept de "contexte" SELinux, en particulier le `type`.
  • Savoir visualiser les contextes des fichiers (`ls -Z`) et des processus (`ps -Z`).
  • Comprendre les 3 modes de SELinux (Enforcing, Permissive, Disabled).
  • Savoir corriger les contextes de fichiers (`chcon`, `restorecon`).

Concepts et Commandes Clés

1. DAC vs MAC

  • DAC (Discretionary Access Control) : Ce sont les permissions Linux standard (`rwx`, `chmod`, `chown`). Le "discrétionnaire" signifie que le *propriétaire* d'un fichier décide qui y a accès.
  • MAC (Mandatory Access Control) : C'est ce que fait SELinux. Une *politique* (policy) globale définie par l'administrateur système (et non le propriétaire du fichier) détermine les accès. Un processus (ex: Apache) ne peut accéder qu'aux fichiers ayant le bon "label", même si les permissions `rwx` le permettent.

2. Le Contexte SELinux

Tout (fichier, processus, port) a une étiquette (label) de sécurité. Format : `user:role:type:level`.
Le 99% du temps, seul le `type` importe.

Exemple : Le processus Apache (`httpd_t`) veut lire un fichier. La politique dit : `httpd_t` peut lire `httpd_sys_content_t`. Si le fichier a ce type, c'est OK. S'il a le type `user_home_t`, l'accès est bloqué.

3. Les 3 Modes SELinux

  • getenforce: Affiche le mode actuel.
  • Enforcing : (Mode par défaut) Bloque les violations ET les logue (`/var/log/audit/audit.log`).
  • Permissive : (Mode de dépannage) Ne bloque RIEN, mais logue les violations. Très utile pour tester une politique.
  • Disabled : Totalement désactivé (nécessite un redémarrage pour (dés)activer).
  • sudo setenforce 0: Passe en mode Permissive (temporairement).
  • sudo setenforce 1: Passe en mode Enforcing (temporairement).
  • sestatus: Donne un état complet (mode, politique chargée, etc.).

4. Visualiser et Corriger les Contextes

  • ls -Z /var/www/html: Affiche le contexte des fichiers.
  • ps -Z | grep httpd: Affiche le contexte des processus.
  • sudo chcon -t httpd_sys_content_t /tmp/index.html: (Change Context) Modifie le type (temporairement, sera perdu si le système est ré-étiqueté).
  • sudo restorecon -v /var/www/html/index.html: (Restore Context) C'est la *meilleure* commande. Elle lit la politique de base pour savoir quel contexte le fichier *devrait* avoir, et l'applique.

Exemples d'application

  • Passer en mode permissif (pour dépannage) : sudo setenforce 0
  • Revener en mode "enforcing" : sudo setenforce 1
  • Vérifier le contexte d'un fichier : ls -Z /etc/shadow
  • Restaurer le contexte par défaut de `/etc/shadow` (après une mauvaise manip) : sudo restorecon -v /etc/shadow
  • Voir le contexte des processus Apache : ps -Z | grep httpd

Section 9 – Travaux Pratiques (TPs) Intégrés

Cette section regroupe des exercices pratiques qui combinent plusieurs concepts vus dans le guide. Essayez de les réaliser dans l'ordre.

TP 1 : Planification d'une Tâche (Section 5)

Objectif : Planifier un script de sauvegarde (fourni) pour une exécution quotidienne avec `cron`.

  1. 1. Enregistrer le script :
    • Créez le répertoire nécessaire : `sudo mkdir -p /root/scripts`
    • Créez le fichier : `sudo vim /root/scripts/backup_etc.sh`
    • Collez-y le contenu suivant (ce script sauvegarde `/etc` et supprime les backups de plus de 7 jours) : 
      #!/bin/bash
BACKUP_DIR="/opt/backups/etc"
FILENAME="etc_backup_$(date +%Y-%m-%d).tar.gz"
mkdir -p "$BACKUP_DIR"
tar -czf "$BACKUP_DIR/$FILENAME" /etc
find "$BACKUP_DIR" -name "etc_backup_*.tar.gz" -mtime +7 -exec rm {} \;
    • Rendez le script exécutable : `sudo chmod +x /root/scripts/backup_etc.sh`
  2. 2. Planifier le script (le cœur de l'exercice) :
    • Créez le fichier `/root/scripts/backup_etc.sh` (créez le dossier si besoin).
    • Ajoutez le contenu suivant : 
      #!/bin/bash
# Script de sauvegarde pour /etc
BACKUP_DIR="/opt/backups/etc"
FILENAME="etc_backup_$(date +%Y-%m-%d).tar.gz"
mkdir -p "$BACKUP_DIR"
tar -czf "$BACKUP_DIR/$FILENAME" /etc
# Bonus : Suppression des backups de plus de 7 jours
find "$BACKUP_DIR" -name "etc_backup_*.tar.gz" -mtime +7 -exec rm {} \;
    • Rendez le script exécutable : `sudo chmod +x /root/scripts/backup_etc.sh`
  3. Planifier le script :
    • Ouvrez la crontab de l'utilisateur `root` : `sudo crontab -e`
    • Ajoutez une ligne pour l'exécuter tous les jours à 2h30 du matin :
      30 2 * * * /root/scripts/backup_etc.sh
    • Vérifiez que la tâche est installée : `sudo crontab -l`

TP 2 : Analyse de Logs et Supervision (Sections 4 & 6)

Objectif : Enquêter sur un problème de performance et d'espace disque.

  1. Diagnostic Espace Disque :
    • Exécutez `df -h`. Si une partition (ex: `/var`) est pleine.
    • Trouvez les 5 plus gros répertoires dans `/var` :
      sudo du -sh /var/* | sort -rh | head -n 5
    • Vous identifiez que `/var/log` est le coupable.
  2. Diagnostic Logs :
    • Trouvez les 10 plus gros fichiers dans `/var/log` : sudo find /var/log -type f -exec du -h {} + | sort -rh | head -n 10
    • Vous trouvez un fichier `debug.log` de 10 Go.
    • Utilisez `journalctl` pour trouver des erreurs système récentes :
      journalctl -p err -S "1 hour ago"

TP 3 : Dépannage SELinux (Section 8)

Objectif : Corriger un problème de contexte SELinux sur un serveur web Apache.

  1. Créer le problème :
    • Assurez-vous qu'Apache est installé (`httpd`) et que SELinux est en mode `Enforcing`.
    • Créez un fichier de test : `echo "Page de test" | sudo tee /tmp/test.html`
    • Déplacez-le dans le répertoire web : `sudo mv /tmp/test.html /var/www/html/`
    • Vérifiez le contexte : `ls -Z /var/www/html/test.html`. Il sera `tmp_t` ou `user_tmp_t`, ce qui est incorrect.
    • Essayez d'accéder à `http://localhost/test.html` (vous obtiendrez une erreur 403 Forbidden).
  2. Diagnostiquer et Corriger :
    • Passez SELinux en mode permissif : `sudo setenforce 0`.
    • Actualisez la page web. Elle fonctionne ! Cela confirme que SELinux est le problème.
    • Remettez SELinux en mode "enforcing" : `sudo setenforce 1`.
    • Corrigez le contexte : `sudo restorecon -v /var/www/html/test.html`
    • Vérifiez à nouveau le contexte : `ls -Z /var/www/html/test.html` (Il doit être `httpd_sys_content_t`).
    • Actualisez la page web. Elle fonctionne, même avec SELinux actif.