Init Linux course

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.
+
+### 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)

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)

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)

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)

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)