From d7221b46f4f096849580ed90646332f106272969 Mon Sep 17 00:00:00 2001 From: hoaraualderic Date: Tue, 26 May 2026 22:18:07 +0200 Subject: [PATCH 1/2] Init Linux course --- 01-introduction-architecture.md | 50 ++++++++++++++ 02-filesystem-hierarchie.md | 65 ++++++++++++++++++ 03-gestion-processus.md | 108 ++++++++++++++++++++++++++++++ 04-memoire-stockage.md | 60 +++++++++++++++++ 05-reseau-linux.md | 91 +++++++++++++++++++++++++ 06-securite-permissions.md | 110 ++++++++++++++++++++++++++++++ 07-administration-logs.md | 61 +++++++++++++++++ 08-performance-tuning.md | 59 ++++++++++++++++ 09-exercices.md | 115 ++++++++++++++++++++++++++++++++ README.md | 45 ++++++++++++- 10 files changed, 762 insertions(+), 2 deletions(-) create mode 100644 01-introduction-architecture.md create mode 100644 02-filesystem-hierarchie.md create mode 100644 03-gestion-processus.md create mode 100644 04-memoire-stockage.md create mode 100644 05-reseau-linux.md create mode 100644 06-securite-permissions.md create mode 100644 07-administration-logs.md create mode 100644 08-performance-tuning.md create mode 100644 09-exercices.md diff --git a/01-introduction-architecture.md b/01-introduction-architecture.md new file mode 100644 index 0000000..6e5d3eb --- /dev/null +++ b/01-introduction-architecture.md @@ -0,0 +1,50 @@ +# 01 - Introduction et Architecture Linux + +[🏠 Accueil](README.md) | [02 - Système de Fichiers →](02-filesystem-hierarchie.md) + +--- + +## 1. Qu'est-ce que Linux ? + +Linux est un noyau (Kernel) de système d'exploitation libre et open-source, créé par **Linus Torvalds** en 1991. Ce que nous appelons couramment "Linux" est en réalité une distribution **GNU/Linux**. + +### Pourquoi Linux ? +- **Stabilité** : Capable de tourner des années sans redémarrer. +- **Sécurité** : Gestion stricte des droits et transparence du code. +- **Performance** : Idéal pour traiter de gros volumes de données. +- **Cloud-Native** : 90% du cloud mondial tourne sous Linux. + +--- + +## 2. Les Distributions (Distros) + +Il existe des centaines de distributions, mais elles se regroupent souvent en familles : +- **Debian / Ubuntu** : La plus populaire, très accessible (Data Science, Web). +- **Red Hat (RHEL) / CentOS / Rocky** : Standard en entreprise pour sa robustesse. +- **Alpine** : Ultra-légère (5MB), parfaite pour les containers Docker. +- **Arch Linux** : Pour les experts qui veulent tout configurer eux-mêmes. + +--- + +## 3. L'Architecture Globale + +Le système est divisé en plusieurs couches : + +### A. Le Kernel (Le Noyau) +C'est le logiciel qui parle directement au matériel (CPU, RAM, Disque). Il gère l'allocation des ressources. + +### B. Le Shell (L'Interpréteur) +L'interface qui permet de communiquer avec le Kernel. (Voir le cours [Bash-Zsh](../Bash-Zsh/README.md)). + +### C. L'User Space (Espace Utilisateur) +C'est là que tournent vos applications (Python, Spark, Docker). Les applications ne parlent jamais au matériel directement, elles font des **System Calls** (Appels système) au Kernel. + +--- + +## 4. Hardware vs Software + +Linux utilise des **Drivers** intégrés directement dans le Kernel pour piloter le matériel. Contrairement à Windows, la plupart des pilotes sont "Ready-to-use" sans installation manuelle. + +--- + +[🏠 Accueil](README.md) | [02 - Système de Fichiers →](02-filesystem-hierarchie.md) diff --git a/02-filesystem-hierarchie.md b/02-filesystem-hierarchie.md new file mode 100644 index 0000000..871ce5d --- /dev/null +++ b/02-filesystem-hierarchie.md @@ -0,0 +1,65 @@ +# 02 - Système de Fichiers et Hiérarchie + +[← 01 - Architecture](01-introduction-architecture.md) | [🏠 Accueil](README.md) | [03 - Gestion des Processus →](03-gestion-processus.md) + +--- + +## 1. La Hiérarchie Standard (FHS) + +Sous Linux, tout part de la racine `/`. Il n'y a pas de `C:` ou `D:`. Tout est monté sous forme d'arborescence unique. + +| Dossier | Contenu | +| --- | --- | +| `/bin` | Binaires essentiels (ls, cp, pwd). Lié à `/usr/bin` sur les distros modernes. | +| `/sbin` | Binaires système réservés à root (fdisk, iptables, mount). | +| `/etc` | Fichiers de configuration du système. | +| `/home` | Dossiers personnels des utilisateurs (`/home/alice`, `/home/bob`). | +| `/root` | Dossier personnel du super-utilisateur (Admin). | +| `/var` | Données variables (Logs dans `/var/log`, bases de données, files de mail). | +| `/tmp` | Fichiers temporaires (effacés au reboot). | +| `/dev` | Fichiers représentants le matériel (disques, clavier, /dev/null). | +| `/proc` | Fichiers virtuels sur l'état du Kernel et des processus (ex: `/proc/cpuinfo`). | +| `/sys` | Interface avec le Kernel pour les périphériques et drivers (plus moderne que `/proc`). | +| `/usr` | Contient la majorité des programmes installés (`/usr/bin`, `/usr/lib`, `/usr/share`). | +| `/lib` | Bibliothèques partagées (`.so`) nécessaires aux binaires de `/bin` et `/sbin`. | +| `/opt` | Logiciels tiers installés manuellement (ex: `/opt/spark`, `/opt/datadog-agent`). | +| `/mnt` | Point de montage temporaire pour les disques (convention). | +| `/media` | Point de montage automatique pour les supports amovibles (clé USB, CD). | +| `/srv` | Données servies par les services du système (ex: `/srv/www` pour un serveur web). | + +--- + +## 2. "Everything is a file" + +C'est l'un des principes fondamentaux de Linux. +- Un texte est un fichier. +- Un dossier est un fichier. +- Un disque dur est un fichier (`/dev/sda`). +- Votre clavier est un fichier. + +Cela permet d'utiliser les mêmes outils (cat, grep, redirection) pour tout manipuler. + +--- + +## 3. VFS (Virtual File System) + +Le **VFS** est une couche d'abstraction du Kernel qui permet de lire n'importe quel type de système de fichiers (ext4, NTFS, NFS, S3 bucket monté) de la même manière. + +### Formats courants : +- **ext4** : Le standard Linux. +- **XFS** : Très performant pour les gros fichiers (Data Warehousing). +- **ZFS / Btrfs** : Fonctionnalités avancées (Snapshots, RAID logiciel). + +--- + +## 4. Les Liens (Links) + +- **Hard Link** : Un deuxième nom pour le même fichier physique. Si on supprime l'original, le lien fonctionne toujours. +- **Symbolic Link (Symlink)** : Un raccourci. Si on supprime l'original, le lien est cassé. + ```bash + ln -s /chemin/vers/original raccourci + ``` + +--- + +[← 01 - Architecture](01-introduction-architecture.md) | [🏠 Accueil](README.md) | [03 - Gestion des Processus →](03-gestion-processus.md) diff --git a/03-gestion-processus.md b/03-gestion-processus.md new file mode 100644 index 0000000..73749eb --- /dev/null +++ b/03-gestion-processus.md @@ -0,0 +1,108 @@ +# 03 - Gestion des Processus + +[← 02 - Filesystem](02-filesystem-hierarchie.md) | [🏠 Accueil](README.md) | [04 - Mémoire et Stockage →](04-memoire-stockage.md) + +--- + +## 1. Qu'est-ce qu'un processus ? + +Un processus est une instance d'un programme en cours d'exécution. Chaque processus possède un identifiant unique appelé **PID** (Process ID). + +### Les états d'un processus : +- **Running (R)** : En cours d'utilisation du CPU. +- **Sleeping (S)** : En attente d'une ressource (disque, réseau). +- **Stopped (T)** : Mis en pause par l'utilisateur. +- **Zombie (Z)** : Terminé mais attend que son parent lise son code de sortie. + +--- + +## 2. Observer les processus + +| Commande | Usage | +| --- | --- | +| `ps aux` | Liste statique de tous les processus. | +| `top` | Tableau de bord dynamique (CPU, RAM). | +| `htop` | Version moderne et colorée de top (recommandé). | +| `pstree` | Affiche la hiérarchie parent/enfant. | + +--- + +## 3. Envoyer des signaux + +On communique avec les processus via des signaux. +```bash +kill -SIGNAL PID +``` + +### Signaux principaux : +- **SIGTERM (15)** : Demande polie de s'arrêter (par défaut). Laisse le temps au programme de sauvegarder. +- **SIGKILL (9)** : Arrêt brutal et immédiat par le Kernel. +- **SIGHUP (1)** : Relance la configuration (souvent pour les serveurs). + +--- + +## 4. Priorité et "Niceness" + +Le Kernel décide quel processus passe sur le CPU. On peut influencer cela avec le **Nice** (de -20 à 19). +- Un processus avec un Nice de 19 est très "gentil" : il laisse passer les autres. +- Un processus avec un Nice de -20 est prioritaire. + +```bash +nice -n 10 python my_heavy_job.py +renice -n 5 -p 1234 +``` + +--- + +## 5. Gestion des Jobs (Arrière-plan) + +Sur un serveur distant, il est fréquent de lancer des tâches longues sans bloquer le terminal. + +### Lancer un processus en arrière-plan +```bash +python pipeline.py & # Le & envoie le processus en background +jobs # Affiche les jobs en cours dans le shell actuel +``` + +### Basculer entre avant-plan et arrière-plan +```bash +Ctrl+Z # Met en pause le processus actif (état Stopped) +bg # Le relance en arrière-plan +fg # Le ramène au premier plan +fg %2 # Ramène le job numéro 2 au premier plan +``` + +### nohup : survivre à la déconnexion +Un processus en background est tué quand on ferme le terminal (signal **SIGHUP**). Pour éviter ça : +```bash +nohup python pipeline.py > output.log 2>&1 & +``` +- `nohup` : Ignore le signal SIGHUP. +- `> output.log 2>&1` : Redirige stdout ET stderr vers un fichier. + +--- + +## 6. Sessions persistantes : screen et tmux + +L'outil incontournable sur un serveur distant : une session qui **survit à votre déconnexion SSH**. + +### tmux (recommandé) +```bash +tmux new -s mon_pipeline # Créer une nouvelle session nommée +Ctrl+B puis D # Se détacher (la session tourne toujours) +tmux attach -t mon_pipeline # Se rattacher depuis une autre connexion SSH +tmux ls # Lister les sessions actives +``` + +### screen (alternative historique) +```bash +screen -S mon_job # Créer une session +Ctrl+A puis D # Se détacher +screen -r mon_job # Se rattacher +``` + +> 💡 **Cas d'usage Data** : Lancer un `spark-submit` dans `tmux`, se déconnecter du VPN, se reconnecter le lendemain et voir le résultat. + +--- + +[← 02 - Filesystem](02-filesystem-hierarchie.md) | [🏠 Accueil](README.md) | [04 - Mémoire et Stockage →](04-memoire-stockage.md) diff --git a/04-memoire-stockage.md b/04-memoire-stockage.md new file mode 100644 index 0000000..5e6d6c1 --- /dev/null +++ b/04-memoire-stockage.md @@ -0,0 +1,60 @@ +# 04 - Mémoire et Stockage + +[← 03 - Processus](03-gestion-processus.md) | [🏠 Accueil](README.md) | [05 - Réseau sous Linux →](05-reseau-linux.md) + +--- + +## 1. Gestion de la RAM et du Swap + +Linux utilise la mémoire vive (RAM) de manière très agressive pour le cache disque. Un serveur Linux qui affiche "0 MB free" n'est pas forcément saturé, il utilise juste le reste pour accélérer les accès fichiers. + +### Commandes : +- `free -h` : Affiche l'utilisation de la RAM et du Swap. +- `vmstat` : Statistiques sur la mémoire virtuelle. + +### Le Swap : +C'est un espace sur le disque utilisé quand la RAM est pleine. +*💡 Conseil Data Eng : Évitez le swap excessif, car les performances s'effondrent.* + +--- + +## 2. Stockage Physique vs Logique + +### Partitionnement +Découpage physique du disque (`/dev/sda1`, `/dev/sda2`). + +### LVM (Logical Volume Manager) +Couche d'abstraction (recommandée) qui permet de : +- Fusionner plusieurs disques physiques en un seul groupe. +- Redimensionner des partitions "à chaud" sans redémarrer. +- Faire des Snapshots. + +--- + +## 3. Montage des systèmes de fichiers + +Sous Linux, pour accéder à un disque, il faut le "monter" dans un dossier. +```bash +mount /dev/sdb1 /mnt/data +``` + +### Le fichier /etc/fstab +C'est ici qu'on définit quels disques doivent être montés automatiquement au démarrage. Une erreur dans ce fichier peut empêcher le serveur de booter ! + +--- + +## 4. Inodes et espace disque + +Chaque fichier consomme : +1. De l'espace disque (les octets). +2. Un **Inode** (l'index du fichier). + +Si vous créez des millions de petits fichiers (ex: logs Spark non agrégés), vous pouvez saturer les Inodes avant de saturer le disque. +```bash +df -h # Espace disque +df -i # Inodes libres +``` + +--- + +[← 03 - Processus](03-gestion-processus.md) | [🏠 Accueil](README.md) | [05 - Réseau sous Linux →](05-reseau-linux.md) diff --git a/05-reseau-linux.md b/05-reseau-linux.md new file mode 100644 index 0000000..a331564 --- /dev/null +++ b/05-reseau-linux.md @@ -0,0 +1,91 @@ +# 05 - Réseau sous Linux + +[← 04 - Stockage](04-memoire-stockage.md) | [🏠 Accueil](README.md) | [06 - Sécurité et Permissions →](06-securite-permissions.md) + +--- + +## 1. Interfaces et Adresses IP + +Linux identifie chaque connexion physique ou virtuelle comme une interface : +- `lo` : Loopback (127.0.0.1), l'adresse locale du serveur. +- `eth0` ou `enp0s3` : Votre connexion Ethernet/WiFi. +- `docker0` : Pont virtuel utilisé par Docker. + +### Commandes : +- `ip addr` : Affiche les interfaces et leurs IPs. (Remplace l'ancien `ifconfig`). +- `ip route` : Affiche la table de routage (la passerelle par défaut). + +--- + +## 2. Ports et Services + +Un serveur peut héberger plusieurs services sur la même IP via des ports : +- HTTP : 80 / HTTPS : 443 +- SSH : 22 +- PostgreSQL : 5432 +- Spark Web UI : 4040 + +### Vérifier qui écoute sur quoi : +```bash +ss -tulpn +``` +*(Remplace l'ancien `netstat`)* + +--- + +## 3. Configuration DNS et Hosts + +- **/etc/hosts** : Annuaire local. Utile pour nommer des serveurs sans DNS. +- **/etc/resolv.conf** : Définit quels serveurs DNS interroger (ex: 8.8.8.8). + +--- + +## 4. Troubleshooting Réseau + +| Commande | Usage | +| --- | --- | +| `ping google.com` | Teste la connectivité basique. | +| `dig google.com` | Teste la résolution DNS. | +| `curl -I http://monsite.com` | Teste la réponse d'un serveur Web. | +| `nc -zv host port` | Netcat : vérifie si un port est ouvert. | +| `traceroute google.com` | Affiche le chemin parcouru par les paquets. | + +--- + +## 5. Firewall sous Linux + +Linux dispose de plusieurs couches pour filtrer le trafic réseau. + +### ufw : L'outil simple (Ubuntu/Debian) +`ufw` (Uncomplicated Firewall) est la façade conviviale pour gérer les règles. +```bash +ufw enable # Activer le firewall +ufw status verbose # Voir les règles actives +ufw allow 22/tcp # Autoriser SSH +ufw allow 443/tcp # Autoriser HTTPS +ufw deny 5432/tcp # Bloquer PostgreSQL depuis l'extérieur +ufw allow from 10.0.0.0/8 # Autoriser un réseau interne uniquement +ufw delete allow 80/tcp # Supprimer une règle +``` + +### iptables / nftables : Le moteur sous-jacent +`ufw` n'est qu'une interface ; c'est `iptables` (ou son successeur `nftables`) qui applique réellement les règles dans le Kernel. + +```bash +iptables -L -n -v # Lister toutes les règles actives +iptables -A INPUT -p tcp --dport 22 -j ACCEPT # Accepter SSH en entrée +iptables -A INPUT -j DROP # Bloquer tout le reste en entrée (règle de fin) +``` + +### Les chaînes principales : +| Chaîne | Rôle | +| --- | --- | +| `INPUT` | Trafic entrant à destination du serveur. | +| `OUTPUT` | Trafic sortant du serveur. | +| `FORWARD` | Trafic qui transite (routeur, conteneur). | + +> 💡 **Conseil** : Sur un serveur de données, n'exposez que les ports strictement nécessaires. Un cluster Kafka/Spark ne devrait jamais avoir ses ports accessibles depuis internet directement. + +--- + +[← 04 - Stockage](04-memoire-stockage.md) | [🏠 Accueil](README.md) | [06 - Sécurité et Permissions →](06-securite-permissions.md) diff --git a/06-securite-permissions.md b/06-securite-permissions.md new file mode 100644 index 0000000..a12a672 --- /dev/null +++ b/06-securite-permissions.md @@ -0,0 +1,110 @@ +# 06 - Sécurité et Permissions Avancées + +[← 05 - Réseau](05-reseau-linux.md) | [🏠 Accueil](README.md) | [07 - Administration et Logs →](07-administration-logs.md) + +--- + +## 1. Au-delà du standard Owner/Group/Other + +Vous connaissez déjà `chmod` et `chown`. Mais Linux propose des mécanismes beaucoup plus fins. + +### ACLs (Access Control Lists) +Permet de donner des droits à un utilisateur spécifique sans changer le groupe du fichier. +```bash +setfacl -m u:guillaume:rw fichier.txt # Donne accès à guillaume +getfacl fichier.txt # Affiche les droits détaillés +``` + +--- + +## 2. Le fichier /etc/sudoers + +Ce fichier définit qui a le droit de devenir "Root" (Admin). On le modifie avec la commande sécurisée `visudo`. + +### Exemple de règle : +`guillaume ALL=(ALL) NOPASSWD: /usr/bin/apt` +*(Autorise guillaume à installer des paquets sans taper son mot de passe)* + +--- + +## 3. Les Sticky Bits et Permissions spéciales + +- **SUID (Set User ID)** : Un fichier s'exécute avec les droits du propriétaire (ex: `/usr/bin/passwd`). +- **SGID** : Un fichier s'exécute avec les droits du groupe. +- **Sticky Bit** : Utilisé sur `/tmp`. Tout le monde peut écrire, mais seul le propriétaire peut supprimer son propre fichier. + +--- + +## 4. Gestion des Utilisateurs et Groupes + +### Les fichiers clés +- **/etc/passwd** : Liste de tous les utilisateurs (nom, UID, GID, shell, home). +- **/etc/shadow** : Mots de passe hashés (lisible uniquement par root). +- **/etc/group** : Liste des groupes et leurs membres. + +### Commandes essentielles +```bash +# Utilisateurs +useradd -m -s /bin/bash alice # Créer un utilisateur avec son home et bash +passwd alice # Définir/changer son mot de passe +usermod -aG docker alice # Ajouter alice au groupe docker +userdel -r alice # Supprimer l'utilisateur et son home + +# Groupes +groupadd datateam # Créer un groupe +groupdel datateam # Supprimer un groupe +id alice # Voir les groupes d'un utilisateur +``` + +### Passer d'un utilisateur à un autre +```bash +su - alice # Se connecter en tant qu'alice (demande son mdp) +sudo su - # Passer root (si sudo configuré) +whoami # Vérifier l'utilisateur actuel +``` + +--- + +## 5. Durcissement SSH (Hardening) + +SSH est la porte d'entrée principale d'un serveur. La sécuriser est non-négociable. + +### Étape 1 : Utiliser des clés SSH à la place des mots de passe +```bash +# Sur votre machine locale +ssh-keygen -t ed25519 -C "mon_serveur_data" # Génère une paire de clés +ssh-copy-id alice@mon-serveur.com # Dépose la clé publique sur le serveur +``` + +### Étape 2 : Durcir /etc/ssh/sshd_config +```bash +# Éditer avec : sudo nano /etc/ssh/sshd_config +PermitRootLogin no # Interdire la connexion directe en root +PasswordAuthentication no # Forcer les clés SSH uniquement +Port 2222 # Changer le port par défaut (réduit le bruit des bots) +AllowUsers alice bob # Whitelist des utilisateurs autorisés +MaxAuthTries 3 # Limite les tentatives avant déconnexion +``` +```bash +sudo systemctl restart sshd # Appliquer les changements +``` + +### Étape 3 : fail2ban (protection brute-force) +`fail2ban` surveille les logs et bannit automatiquement les IPs qui échouent trop souvent. +```bash +apt install fail2ban +systemctl enable --now fail2ban +fail2ban-client status sshd # Voir les IPs bannies sur SSH +``` + +--- + +## 6. Introduction au durcissement (Hardening système) + +- **SELinux / AppArmor** : Couches de sécurité obligatoires (MAC) qui empêchent même un processus Root de faire n'importe quoi si ce n'est pas explicitement autorisé. + - **SELinux** : Standard sur Red Hat / Rocky Linux. Mode `enforcing` pour la production. + - **AppArmor** : Standard sur Ubuntu/Debian. Plus simple à configurer. + +--- + +[← 05 - Réseau](05-reseau-linux.md) | [🏠 Accueil](README.md) | [07 - Administration et Logs →](07-administration-logs.md) diff --git a/07-administration-logs.md b/07-administration-logs.md new file mode 100644 index 0000000..230cc33 --- /dev/null +++ b/07-administration-logs.md @@ -0,0 +1,61 @@ +# 07 - Administration Système et Logs + +[← 06 - Sécurité](06-securite-permissions.md) | [🏠 Accueil](README.md) | [08 - Performance et Tuning →](08-performance-tuning.md) + +--- + +## 1. Gestion des Services avec Systemd + +Sur presque toutes les distros modernes, **systemd** est le premier processus (PID 1) qui gère tous les autres services. + +### Commandes `systemctl` : +- `systemctl start docker` : Démarrer un service. +- `systemctl stop docker` : L'arrêter. +- `systemctl restart docker` : Redémarrer. +- `systemctl enable docker` : Activer au démarrage du serveur. +- `systemctl status docker` : Voir si tout va bien. + +--- + +## 2. Automatisation : Crontab + +Le démon **cron** permet de planifier des tâches (jobs ETL, backups). +```bash +crontab -e # Éditer ses tâches +``` + +### Syntaxe (M H D M D) : +`0 2 * * * /home/guillaume/backup.sh` +*(Lance le backup tous les jours à 2h00 du matin)* + +--- + +## 3. Analyse des Logs Système + +Les logs sont vos meilleurs amis quand un pipeline Data échoue mystérieusement. + +- **/var/log/syslog** ou **/var/log/messages** : Logs généraux du système. +- **/var/log/auth.log** : Tentatives de connexion. +- **/var/log/dmesg** : Messages du Kernel (Hardware). + +### Journalctl (L'outil moderne) +Remplace la lecture directe des fichiers pour systemd. +```bash +journalctl -u docker # Logs de Docker uniquement +journalctl -f # Suivre les logs en temps réel +journalctl -p err # Voir uniquement les erreurs +``` + +--- + +## 4. Gestion des paquets + +| Famille | Commande | Exemple | +| --- | --- | --- | +| **Debian/Ubuntu** | `apt` | `apt install htop` | +| **RedHat/Rocky** | `dnf` | `dnf install git` | +| **Alpine** | `apk` | `apk add bash` | + +--- + +[← 06 - Sécurité](06-securite-permissions.md) | [🏠 Accueil](README.md) | [08 - Performance et Tuning →](08-performance-tuning.md) diff --git a/08-performance-tuning.md b/08-performance-tuning.md new file mode 100644 index 0000000..4fc6fcc --- /dev/null +++ b/08-performance-tuning.md @@ -0,0 +1,59 @@ +# 08 - Performance et Tuning (Expert) + +[← 07 - Administration](07-administration-logs.md) | [🏠 Accueil](README.md) | [09 - Exercices →](09-exercices.md) + +--- + +## 1. Monitoring Avancé + +Quand un cluster Spark est lent, il faut savoir identifier le goulot d'étranglement (Bottleneck). + +### L'approche USE (Utilization, Saturation, Errors) +- **iostat** : Performance des disques (I/O Wait). +- **sar** : Historique complet des performances. +- **nload** : Visualisation du trafic réseau. + +--- + +## 2. Kernel Tuning via /proc et sysctl + +Le Kernel Linux a des milliers de paramètres ajustables sans redémarrer. + +### Exemple : Swappiness +Définit à quel point Linux doit utiliser le Swap. Pour la Data, on veut souvent le baisser (ex: 10). +```bash +sysctl -w vm.swappiness=10 +``` + +### Exemple : File Descriptors +Les serveurs de données ouvrent beaucoup de fichiers/sockets. On augmente souvent la limite : +```bash +ulimit -n 65535 +``` + +--- + +## 3. Comprendre le "Load Average" + +Affiché dans `top` : `0.50, 1.20, 2.50` +- Moyenne sur 1 min, 5 min, 15 min. +- **Si Load > Nombre de CPUs** : Le système est surchargé (processus en attente). + +--- + +## 4. Troubleshooting Expert + +- **`strace`** : Trace tous les appels système d'un programme. Utile pour savoir pourquoi un binaire plante sans message d'erreur. +- **`lsof`** : List Open Files. Savoir quel processus bloque un fichier ou un port. +- **`iotop`** : Quel processus utilise tout le disque ? + +--- + +## 5. HugePages et Cgroups + +- **HugePages** : Optimise la gestion des grandes quantités de RAM pour les bases de données. +- **Cgroups** : Le mécanisme qui limite les ressources des containers (Docker/Kubernetes). + +--- + +[← 07 - Administration](07-administration-logs.md) | [🏠 Accueil](README.md) | [09 - Exercices →](09-exercices.md) diff --git a/09-exercices.md b/09-exercices.md new file mode 100644 index 0000000..dd97360 --- /dev/null +++ b/09-exercices.md @@ -0,0 +1,115 @@ +# 09 - Exercices : Linux + +[← 08 - Performance](08-performance-tuning.md) | [🏠 Accueil](README.md) + +--- + +## Exercice 1 : Navigation et Filesystem +1. Trouvez le chemin absolu de votre répertoire personnel. +2. Créez un lien symbolique nommé `mes_logs` pointant vers `/var/log`. +3. Listez tous les fichiers de `/etc` finissant par `.conf`. + +## Exercice 2 : Processus et Signaux +1. Lancez une commande `sleep 1000 &` en arrière-plan. +2. Trouvez son PID. +3. Changez sa priorité (nice) à 15. +4. Tuez le processus proprement (SIGTERM), puis vérifiez qu'il n'est plus là. + +## Exercice 3 : Stockage et Montage +1. Affichez l'espace disque restant en format lisible. +2. Trouvez quel dossier dans `/var` consomme le plus d'espace. +3. Affichez le nombre d'inodes libres sur votre partition principale. + +## Exercice 4 : Réseau +1. Trouvez votre adresse IP locale. +2. Listez tous les ports en écoute sur votre machine. +3. Vérifiez si vous pouvez contacter `google.com` sur le port 443 via `nc` ou `telnet`. + +## Exercice 5b : Utilisateurs, Groupes et SSH + +1. Créez un utilisateur `datascientist` avec un répertoire home et le shell bash. +2. Créez un groupe `datateam` et ajoutez `datascientist` à ce groupe. +3. Vérifiez les groupes de cet utilisateur avec la commande appropriée. +4. Générez une paire de clés SSH `ed25519` sur votre machine. +5. Dans `/etc/ssh/sshd_config`, trouvez et notez la valeur de `PermitRootLogin`. + +## Exercice 5 : Administration et Logs +1. Affichez les 50 dernières lignes du log système. +2. Vérifiez si le service `docker` (ou un autre service installé) est configuré pour démarrer automatiquement. +3. Planifiez une tâche cron qui écrit "Hello" dans un fichier `/tmp/hello.txt` chaque minute. + +## Exercice 6 : Performance et Tuning + +1. Affichez la valeur actuelle de `vm.swappiness` sur votre système. +2. Changez-la temporairement à `10` et vérifiez que le changement est bien pris en compte. +3. Identifiez le processus qui consomme le plus d'I/O disque en ce moment. +4. Affichez le Load Average actuel et comparez-le au nombre de CPUs de votre machine. +5. Listez tous les fichiers ouverts par le processus `sshd` (utilisez `lsof`). + +## Exercice 7 : Jobs et Sessions persistantes + +1. Lancez `sleep 300` en arrière-plan avec `&`. +2. Vérifiez qu'il tourne avec `jobs`. +3. Mettez-le en pause avec `Ctrl+Z`, puis relancez-le en arrière-plan avec `bg`. +4. Créez une session `tmux` nommée `test`, lancez `top` dedans, puis détachez-vous. +5. Listez vos sessions `tmux` actives et rattachez-vous à la session `test`. + +--- + +## 💡 Solutions (Résumé) + +
+Cliquez pour voir les solutions + +### Ex 1 +1. `pwd` +2. `ln -s /var/log mes_logs` +3. `ls /etc/*.conf` + +### Ex 2 +1. `sleep 1000 &` +2. `ps aux | grep sleep` ou `pgrep sleep` +3. `renice -n 15 -p ` +4. `kill ` (ou `kill -15 `) + +### Ex 3 +1. `df -h` +2. `du -sh /var/* | sort -rh | head -n 1` +3. `df -i` + +### Ex 4 +1. `ip addr` +2. `ss -tulpn` +3. `nc -zv google.com 443` + +### Ex 5b +1. `useradd -m -s /bin/bash datascientist` +2. `groupadd datateam` puis `usermod -aG datateam datascientist` +3. `id datascientist` +4. `ssh-keygen -t ed25519 -C "mon_serveur"` +5. `grep PermitRootLogin /etc/ssh/sshd_config` + +### Ex 5 +1. `tail -n 50 /var/log/syslog` (ou `journalctl -n 50`) +2. `systemctl is-enabled docker` +3. `crontab -e` puis `* * * * * echo "Hello" >> /tmp/hello.txt` + +### Ex 6 +1. `sysctl vm.swappiness` +2. `sudo sysctl -w vm.swappiness=10` puis vérifier avec `sysctl vm.swappiness` +3. `sudo iotop -o` (affiche seulement les processus actifs en I/O) +4. `uptime` pour le Load Average, `nproc` pour le nombre de CPUs +5. `sudo lsof -c sshd` + +### Ex 7 +1. `sleep 300 &` +2. `jobs` +3. `Ctrl+Z` puis `bg` +4. `tmux new -s test`, lancer `top`, puis `Ctrl+B D` +5. `tmux ls` puis `tmux attach -t test` + +
+ +--- + +[← 08 - Performance](08-performance-tuning.md) | [🏠 Accueil](README.md) diff --git a/README.md b/README.md index f21e300..a92651e 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,43 @@ -# cours-linux -Complément de cours sur Linux +# Formation Linux : De Zéro à Expert + +Linux est le système d'exploitation qui fait tourner le cloud, les serveurs de données et les pipelines Big Data (Spark, Kafka, Kubernetes). Maîtriser Linux n'est pas une option, c'est une nécessité. + +## 🎯 Objectifs Pédagogiques + +À la fin de ce cours, vous serez capable de : +- Comprendre l'architecture interne du système Linux. +- Gérer les processus, la mémoire et le stockage de manière avancée. +- Administrer des serveurs et configurer le réseau. +- Sécuriser un environnement Linux. +- Optimiser les performances système (Kernel Tuning). + +## 📚 Programme + +### [01 - Introduction et Architecture](01-introduction-architecture.md) +Découvrez l'histoire de Linux, les distributions et l'architecture globale (Kernel, Shell, User Space). + +### [02 - Système de Fichiers et Hiérarchie](02-filesystem-hierarchie.md) +Comprendre où sont stockées les données et la structure VFS (Virtual File System). + +### [03 - Gestion des Processus](03-gestion-processus.md) +Le cycle de vie d'un processus, les signaux, et la gestion des ressources. + +### [04 - Mémoire et Stockage](04-memoire-stockage.md) +RAM, Swap, Virtual Memory, et la gestion des disques (LVM, Partitions, Montages). + +### [05 - Réseau sous Linux](05-reseau-linux.md) +Protocoles, interfaces, DNS, ports et troubleshooting réseau. + +### [06 - Sécurité et Permissions Avancées](06-securite-permissions.md) +Au-delà du chmod : ACLs, Sudoers, et introduction à SELinux/AppArmor. + +### [07 - Administration Système et Logs](07-administration-logs.md) +Systemd, services, cron, et analyse des logs système. + +### [08 - Performance et Tuning (Expert)](08-performance-tuning.md) +Optimisation du Kernel pour la Data, monitoring avancé et troubleshooting expert. + +### [09 - Exercices Pratiques](09-exercices.md) +Mise en pratique des concepts abordés. + +--- \ No newline at end of file From 6848976e1c3969e6e909aeb570d0096606e92c96 Mon Sep 17 00:00:00 2001 From: hoaraualderic Date: Tue, 26 May 2026 22:20:58 +0200 Subject: [PATCH 2/2] docs: remove reference to Bash-Zsh course in Shell section --- 01-introduction-architecture.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/01-introduction-architecture.md b/01-introduction-architecture.md index 6e5d3eb..77ead95 100644 --- a/01-introduction-architecture.md +++ b/01-introduction-architecture.md @@ -34,7 +34,7 @@ Le système est divisé en plusieurs couches : C'est le logiciel qui parle directement au matériel (CPU, RAM, Disque). Il gère l'allocation des ressources. ### B. Le Shell (L'Interpréteur) -L'interface qui permet de communiquer avec le Kernel. (Voir le cours [Bash-Zsh](../Bash-Zsh/README.md)). +L'interface qui permet de communiquer avec le Kernel. ### C. L'User Space (Espace Utilisateur) C'est là que tournent vos applications (Python, Spark, Docker). Les applications ne parlent jamais au matériel directement, elles font des **System Calls** (Appels système) au Kernel.