$
Apprendre Manuel Linux
fr
XP :0
L

Invité.

Utilisateur Niveau 1

Progression XP0 / 300
Terminé0 / 150
Badges Débloqués0

Aucune inscription requise. Progression sauvegardée localement. Exportez votre code pour continuer sur un autre appareil.

BADGES OBTENUS

Pratique du Terminal Linux en Ligne — Apprenez par la Pratique.

Maîtrisez les commandes Linux essentielles grâce à un jeu d'apprentissage bash gratuit et une simulation interactive de système de fichiers.

Terminal Linux en Ligne150+ Quêtes & ObjectifsPratique Gratuite en LigneJeu d'Apprentissage Bash Interactif

Parcours d'Apprentissage Interactif & Objectifs de Terminal.

Votre parcours complet d'apprentissage Linux avec des objectifs clairs. Cliquez sur un défi débloqué pour ouvrir votre terminal interactif.

1. Bases du Système de Fichiers

Quête 1Verrouillé

Imaginez-vous entrer dans une bibliothèque immense et sombre contenant des millions de livres, mais vous n'avez pas de carte et vous ne vous souvenez même pas de votre propre badge. Avant de pouvoir rechercher quoi que ce soit, vous devez savoir qui vous êtes et où vous vous situez. Dans le shell Linux, nous commençons par exactement les mêmes questions ! - La commande `whoami` imprime le nom d'utilisateur sous lequel vous êtes actuellement connecté. - La commande `pwd` (imprimer le répertoire de travail) agit comme un GPS, vous indiquant le chemin exact du dossier où vous vous trouvez actuellement.

Quête 2Verrouillé

Maintenant que vous savez où vous êtes, comment regarder autour de vous et vous déplacer vers une autre pièce de cette bibliothèque numérique ? Sous Linux, nous faisons cela à l'aide de deux commandes simples : - `ls` : C'est comme allumer les lumières d'une pièce pour voir tous les fichiers et dossiers qui s'y trouvent. - `cd <path>` : Abréviation de "changer de répertoire", cela vous permet de franchir une porte vers un autre dossier. Pour spécifier où vous souhaitez aller, vous pouvez utiliser des chemins **absolus** (en commençant à partir de la racine `/` du système, comme `/var/log`) ou des chemins **relatifs** (en fonction de l'endroit où vous vous trouvez actuellement, comme utiliser `..` pour revenir dans le dossier parent).

Quête 3Verrouillé

A standard `ls` lists only the names of files, giving you no indication of how large they are, who owns them, or when they were last modified. In Linux, we inspect detailed file metadata using the long listing option: - The `-l` (long) option shows permissions, link counts, file owner, group, exact size in bytes, and last modification date. - The `-h` (human-readable) option, when combined with `-l` as `ls -lh`, translates raw byte counts into intuitive units like `K` (kilobytes), `M` (megabytes), and `G` (gigabytes).

Quête 4Verrouillé

Imaginez que votre bureau est rempli de papiers volants et que vous avez besoin de dossiers physiques pour garder les choses bien rangées. Sous Linux, nous organisons les fichiers en créant des dossiers (répertoires) à l'aide de la commande `mkdir` (make directory). L'exécution de `mkdir code` crée un tout nouveau dossier nommé « code » là où vous vous trouvez. Vous pouvez créer des dossiers n'importe où dans le système de fichiers en donnant à `mkdir` un chemin relatif ou absolu.

Quête 5Verrouillé

Imaginez que vous essayiez de construire un ensemble de poupées gigognes, mais que vous deviez construire celles les plus extérieures avant de pouvoir construire la petite à l'intérieur. Par défaut, `mkdir` est comme ça : il refuse de créer un dossier au plus profond de dossiers qui n'existent pas encore. Pour éviter les tracas liés à la création de dossiers un par un, nous utilisons un commutateur : - L'option `-p` (ou `--parents`) indique à `mkdir` de créer automatiquement tous les dossiers parents manquants avant d'accéder au dossier final. Par exemple, `mkdir -p workspace/src/utils` crée `workspace`, `workspace/src` et `workspace/src/utils` en une seule commande. **Pourquoi est-ce important** : Si vous exécutez `mkdir workspace/src/utils` sans `-p` et que `workspace` et `workspace/src` n'existent pas déjà, vous obtiendrez : `mkdir: cannot create directory 'workspace/src/utils': No such file or directory`. L'indicateur `-p` résout ce problème en créant automatiquement tous les dossiers parents manquants.

Quête 6Verrouillé

When navigating complex project directories, flat listings from `ls` make it difficult to visualize nested structures. The `tree` command recursively lists directory contents in a clear, tree-like ASCII visual hierarchy with branch lines showing directory nesting. In large repositories, a full recursive tree can produce thousands of lines. To keep output manageable, use the `-L <level>` switch (e.g., `tree -L 2`) to restrict visualization depth to a specific number of directory levels.

Quête 7Verrouillé

Chaque système Linux suit une hiérarchie de système de fichiers standard en commençant par le répertoire racine `/`. Contrairement à Windows (qui utilise des lettres de lecteur comme `C:` ou `D:`), Linux unifie tous les fichiers et le stockage sous `/`. Voici les répertoires système clés que tout utilisateur Linux devrait connaître : - `/` (Root) : Le dossier parent de niveau supérieur de l'ensemble du système. - `/etc` : contient les configurations du système (par exemple `/etc/hosts`, `/etc/passwd`). - `/var` : contient des données variables qui changent au fil du temps (journaux, spool, caches comme `/var/log`). - `/home` : Dossiers personnels de l'utilisateur (par exemple `/home/learner`). - `/tmp` : Zone de stockage temporaire des fichiers transitoires. - `/usr` : utilitaires utilisateur, applications et bibliothèques système.

Quête 8Verrouillé

In Linux, file extensions (like `.txt` or `.png`) are merely hints for humans—the operating system does not rely on them. To identify what a file truly contains, the `file` command reads the file's binary header (magic bytes) and determines its actual format (ASCII text, ELF executable, gzip archive, etc.). To inspect deep filesystem metadata beyond what `ls -l` shows, the `stat` command displays the file's exact size in bytes, allocated blocks, filesystem inode number, octal access permissions (e.g. `0644`), and exact timestamps: Access (`atime`), Modify (`mtime`), and Change (`ctime`).

Quête 9Verrouillé

Vous êtes-vous déjà senti submergé lorsque votre bureau est couvert de notes et de papiers en désordre ? Votre terminal peut devenir tout aussi encombré. Lorsque c’est le cas, vous pouvez effacer tout l’ancien texte et repartir à zéro. - La commande `clear` efface l'écran visible, en faisant glisser la sortie précédente hors de vue afin que vous ayez une nouvelle toile vierge en haut du terminal.

Quête 10Verrouillé

Lorsque vous achetez un nouveau jeu de société, vous jetez généralement un coup d'œil au livre de règles ou à la carte de référence pour voir quels mouvements sont autorisés. Dans notre émulateur de terminal, vous disposez d'un aide-mémoire intégré ! - La commande `help` répertorie toutes les commandes prises en charge par ce simulateur, ainsi que des détails indiquant si elle prend en charge la canalisation ou la redirection des sorties.

👑 Boss · Quête 11Verrouillé

EMERGENCY ALERT: A faulty CI/CD deployment script executed an unconstrained cleanup routine and wiped the directory tree under `/home/learner/app`. The backend production daemon refuses to start until the project directory structure is restored. To recover, you must reconstruct the missing directory hierarchy: create `/home/learner/app/logs`, `/home/learner/app/config`, and the nested module directory `/home/learner/app/src/modules`. No step-by-step hints are provided for Boss Challenges. Inspect the system, plan your approach, and verify your filesystem state.

2. Manipulation de Fichiers

Quête 12Verrouillé

Imaginez que vous vouliez commencer à écrire une nouvelle entrée de journal, mais que vous ayez d'abord besoin d'une feuille de papier vierge. Sous Linux, nous récupérons un nouveau fichier texte vide à l'aide de la commande `touch`. - La commande `touch` crée un tout nouveau fichier vide s'il n'existe pas encore (comme exécuter `touch draft.txt` pour créer `draft.txt`). Si le fichier existe déjà, il met simplement à jour l'horodatage de la « dernière modification » du fichier sans modifier son contenu. Mettons un fichier dans notre nouveau dossier de projets.

Quête 13Verrouillé

Pensez à ouvrir un dossier, à extraire une page de texte et à la tenir pour la lire. Sous Linux, nous lisons les fichiers instantanément sans ouvrir un éditeur de texte lourd à l'aide de la commande `cat` (concaténer). - La commande `cat` imprime l'intégralité du contenu d'un fichier directement sur l'écran de votre terminal. Par exemple, exécuter `cat notes.txt` vous permet de voir immédiatement ce qui est écrit dans `notes.txt`.

Quête 14Verrouillé

Maintenant que vous pouvez lire un fichier entier avec `cat`, que se passe-t-il si le fichier contient des milliers de lignes et que vous souhaitez voir uniquement le haut ou le bas ? Le dumping d'un énorme fichier avec `cat` inonde votre écran. Au lieu de cela, nous utilisons `head` et `tail` pour jeter un œil aux bords. - La commande `head` affiche par défaut les 10 premières lignes d'un fichier. Vous pouvez modifier cela en utilisant `-n <number>` (par exemple `head -n 5 log.txt` pour les 5 premières lignes). - La commande `tail` affiche les 10 dernières lignes par défaut, prenant en charge la même option `-n`. - Surtout, `tail -f` (suivre) surveille un fichier en temps réel, affichant les nouvelles lignes au fur et à mesure qu'elles sont écrites par le système. Il s'agit de l'outil préféré d'un administrateur système pour regarder les journaux en direct.

Quête 15Verrouillé

Jetez un œil en haut et en bas d'un fichier avec `head` et `tail`, c'est bien, mais que se passe-t-il si vous devez parcourir un long fichier de configuration page par page ? C'est à cela que servent les téléavertisseurs comme `less` et `more`. - Les téléavertisseurs chargent les fichiers de manière interactive, affichant une page de texte à la fois pour éviter les ralentissements du système sur les fichiers volumineux. - `less` est le choix moderne, vous permettant de faire défiler vers l'avant et vers l'arrière à l'aide des touches fléchées, de rechercher du texte avec `/` et de quitter en appuyant sur `q`. - `more` est un téléavertisseur plus ancien et plus simple qui ne fait que défiler vers l'avant.

Quête 16Verrouillé

Si vous dites à un robot de « peindre ma chambre en bleu », il doit savoir si « ma chambre » est un seul endroit ou si « ma » et « chambre » sont deux instructions différentes. Linux utilise des espaces pour séparer les commandes de leurs arguments. Donc, si vous exécutez `mkdir my folder`, Linux pense que vous souhaitez créer deux dossiers distincts : un nommé « mon » et un autre nommé « dossier » ! - Pour indiquer à Linux qu'un nom avec des espaces est un élément unique, nous devons le mettre entre guillemets (`"my folder"` ou `'my folder'`) ou utiliser une barre oblique inverse pour échapper à l'espace (`my\ folder`).

Quête 17Verrouillé

Si vous souhaitez écrire un message sur un tableau, vous devez d'abord essuyer complètement le tableau, puis écrire vos nouveaux mots. Sous Linux, nous écrivons des messages dans des fichiers à l'aide de l'opérateur `>` (redirection de sortie). - La commande `echo "message"` imprime normalement le texte à l'écran. - En ajoutant le symbole `>`, nous redirigeons ce texte vers un fichier. Par exemple, `echo "Hi" > greeting.txt` écrit « Salut » dans `greeting.txt`. Si le fichier contient déjà du texte, `>` l'écrase complètement avec le nouveau message.

Quête 18Verrouillé

Au lieu de nettoyer le tableau, que se passe-t-il si vous souhaitez simplement ajouter une nouvelle ligne en bas ? Sous Linux, nous ajoutons du texte à la fin d'un fichier sans toucher au contenu existant à l'aide de l'opérateur `>>` (ajouter la redirection). - L'opérateur `>>` ajoute votre nouveau texte tout en bas du fichier. Par exemple, `echo "New Line" >> logs.txt` ajoute « Nouvelle ligne » à la fin de `logs.txt` tout en gardant tous vos anciens journaux en sécurité.

Quête 19Verrouillé

Imaginez réorganiser votre pièce : parfois vous souhaitez faire une photocopie d'un document à conserver dans un autre tiroir, et d'autres fois vous souhaitez simplement saisir un dossier et le glisser dans une nouvelle étagère ou changer son étiquette. Nous faisons cela sous Linux avec des commandes simples : - `cp <source> <destination>` crée une copie identique d'un fichier dans un nouvel emplacement. - `mv <source> <destination>` déplace un fichier vers un nouveau dossier ou renomme le fichier si vous le conservez dans le même dossier (par exemple, `mv old.txt new.txt`).

Quête 20Verrouillé

Imaginez que vous ayez une pile de dossiers étiquetés "log_monday", "log_tuesday" et "log_wednesday", et que vous souhaitiez les ouvrir et les lire tous en même temps sans taper chaque nom. Linux vous permet d'utiliser des **caractères génériques** comme raccourcis de recherche ! - Le symbole `*` correspond à n'importe quel caractère de n'importe quelle longueur. Par exemple, `cat log_*` lit chaque fichier commençant par "log_". - Le symbole `?` agit comme un espace réservé à un seul caractère. Par exemple, `log_?.txt` correspond à `log_1.txt` mais ignorera `log_12.txt`.

Quête 21Verrouillé

Lorsque vous nettoyez votre bureau physique, vous pouvez jeter de vieux papiers dans une corbeille de recyclage où vous pourrez les récupérer si vous avez commis une erreur. Sous Linux, il n'y a pas de filet de sécurité : lorsque vous supprimez quelque chose du terminal, il disparaît à jamais ! - La commande `rm` supprime les fichiers. - Étant donné que les dossiers peuvent contenir d'autres fichiers, `rm` ne supprimera pas de dossier par défaut. Vous devez ajouter l'indicateur `-r` (récursif) pour indiquer à Linux de plonger et de supprimer le dossier ainsi que tout ce qu'il contient. **Pourquoi est-ce important** : Si vous exécutez `rm downloads` sans `-r` lorsque `downloads` est un dossier, vous obtiendrez : `rm: cannot remove 'downloads': Is a directory`. L'indicateur `-r` indique à Linux de supprimer récursivement le dossier et tout ce qu'il contient.

Quête 22Verrouillé

Bash **brace expansion** `{}` is a powerful productivity feature that generates arbitrary string combinations before commands run, eliminating repetitive typing: - Comma-separated lists: `mkdir -p app/{src,bin,logs}` expands to `app/src`, `app/bin`, and `app/logs` in a single command. - Numeric or alphabetic ranges: `touch file_{1..3}.txt` expands to `file_1.txt`, `file_2.txt`, and `file_3.txt`. When deleting folders, `rm -r` deletes everything recursively without safety checks. By contrast, `rmdir` provides a strict safety guarantee: it **only removes directories that are completely empty**, preventing accidental loss of files.

👑 Boss · Quête 23Verrouillé

INCIDENT REPORT: An aborted container update left messy temporary build artifacts in `/home/learner`. The leftover files `temp_install.tmp` and `old_log.txt` are creating conflicts. Furthermore, the verified staging configuration `/home/learner/staging.conf` was never promoted to production. Purge the obsolete temporary files and establish `/home/learner/production.conf` with the configuration from staging. This is a Boss Challenge: evaluate the files, execute the cleanup, and prepare the production configuration.

3. Tubes et Filtrage

Quête 24Verrouillé

Imaginez une chaîne de montage où un travailleur emballe un produit et le remet immédiatement au prochain travailleur pour l'emballer dans une boîte - aucun stockage intermédiaire n'est nécessaire. Sous Linux, nous connectons les commandes exactement comme ceci en utilisant un **pipe** (`|`). - Un tube (`|`) achemine la sortie d'une commande directement vers l'entrée de la commande suivante. Par exemple, `ls | wc -l` répertorie les fichiers et transmet immédiatement cette liste à `wc -l` (nombre de mots - lignes), qui les compte à la volée sans avoir besoin de fichiers temporaires. **Pourquoi est-ce important** : Si vous exécutez `wc` sans `-l`, il génère trois nombres distincts : des lignes, des mots et des octets (par exemple, ` 5 10 85`). Cela rend difficile son utilisation dans des pipelines ou des scripts qui nécessitent un décompte propre et unique. L'indicateur `-l` limite la sortie au seul nombre de lignes.

Quête 25Verrouillé

Imaginez trier un jeu de cartes où les doublons sont dispersés partout. Pour repérer et supprimer facilement les doublons, vous devez d’abord regrouper les cartes identiques. Sous Linux, la commande `uniq` filtre les lignes répétitives, mais elle a un problème : elle **détecte uniquement les doublons les uns à côté des autres** ! - Pour supprimer tous les doublons d'une liste désordonnée, vous devez d'abord trier les lignes à l'aide de `sort` puis transmettre le résultat à `uniq`. Par exemple, `sort raw.txt | uniq` organise et nettoie la liste en une seule fois.

Quête 26Verrouillé

Imaginez parcourir un énorme journal de bord de mille pages pour trouver chaque fois qu'une erreur système se produit. Faire cela manuellement prendrait des heures ! Sous Linux, nous utilisons `grep` comme loupe numérique pour rechercher instantanément des mots ou des modèles spécifiques. - La commande `grep` filtre les fichiers ou le texte redirigé, en imprimant uniquement les lignes qui correspondent à votre mot de recherche. Par exemple, l'exécution de `grep "ERROR" logs.txt` analyse le fichier et extrait uniquement les lignes contenant « ERREUR ».

Quête 27Verrouillé

In plumbing, a T-pipe splits a single water stream into two paths. In Linux, the `tee` command does the exact same thing with text streams: it reads standard input and writes it simultaneously to both the screen (stdout) and one or more files. E.g.: `cmd | tee output.log`. Furthermore, `tee` solves a classic Linux permissions pitfall: running `sudo echo "config" > /etc/app.conf` fails because redirection `>` is handled by your unprivileged shell before `sudo` executes. Piping to `sudo tee -a /etc/app.conf` (where `-a` appends) runs `tee` with superuser privileges, safely writing to protected system files.

Quête 28Verrouillé

In production environments, servers fail when configuration files silently diverge over time—a problem called "configuration drift". The `diff` utility compares two text files line by line and highlights every difference: - Standard format: `diff file1.conf file2.conf` uses `<` to indicate lines from the first file and `>` for lines in the second file. - Unified format: `diff -u file1.conf file2.conf` produces unified diff output (`-` for removed lines, `+` for added lines), which is the standard format used by Git patches and modern pull requests.

Quête 29Verrouillé

While basic `grep` searches for exact strings, production log analysis requires powerful matching flags: - `-i`: Case-insensitive search (matches `error`, `Error`, or `ERROR`). - `-v`: Invert match (prints lines that do **not** match the given pattern, perfect for stripping noise). - `-r` (or `-R`): Recursive directory search across all subdirectories and files. - `-E`: Extended regular expressions (supports `|` alternation for multiple patterns, `+`, and parentheses without escape backslashes).

👑 Boss · Quête 30Verrouillé

SECURITY ALERT: The server logged dozens of suspicious requests in `/home/learner/access.log`. The SOC team needs a clean, deduplicated list of attacking IP addresses to update the network firewall blocklist. Process the raw web server log to extract all unique IP addresses, sort them, and save the result into `/home/learner/banned_ips.txt`. Analyze the data pipeline and construct a command pipeline to generate the required forensic report.

4. Redirection et Sécurité

Quête 31Verrouillé

Imaginez diriger une entreprise où seuls les gestionnaires peuvent signer des chèques, les employés peuvent lire les horaires et les visiteurs ne peuvent regarder que l'enseigne du magasin. Sous Linux, nous contrôlons qui peut lire, écrire ou exécuter des fichiers à l'aide d'un système de sécurité numérique (appelé représentation octale) : - `7` = Accès complet : Lecture + Écriture + Exécution (`rwx`) - `6` = Modifier l'accès : Lecture + Écriture (`rw-`) - `5` = Accès en lecture et exécution : Lecture + Exécution (`r-x`) - `4` = Accès en lecture seule : Lecture (`r--`) Nous appliquons ces paramètres avec `chmod <octal> <file>`. Par exemple, `chmod 755 script.sh` vous permet d'exécuter le script, tandis que d'autres peuvent uniquement le lire et l'exécuter. Nous avons un script nommé `deploy.sh` qui est actuellement verrouillé : rendons-le exécutable !

Quête 32Verrouillé

Pensez à un tiroir secret sous votre bureau dans lequel vous conservez les paramètres système afin qu'ils n'encombrent pas votre espace de travail principal. Sous Linux, nous créons des fichiers cachés simplement en commençant leur nom par un point (`.`). - Ces fichiers dot (comme `.bashrc` ou `.config`) stockent les préférences utilisateur et les paramètres de configuration en arrière-plan. - Une commande standard `ls` ne les affichera pas. Pour jeter un œil à ces fichiers cachés, vous devez ajouter l'indicateur `-a` (all), en exécutant `ls -a`. **Pourquoi est-ce important** : Si vous exécutez `ls` sans `-a`, les fichiers cachés (dont les noms commencent par `.`) sont complètement omis de la sortie. Vous ne verrez pas les fichiers importants comme `.config_names` et pourriez penser qu'ils sont manquants. L'indicateur `-a` indique à `ls` de lister tous les fichiers, y compris ceux masqués.

Quête 33Verrouillé

Imaginez acheter une maison et devoir enregistrer officiellement l'acte sous le nom d'un nouveau propriétaire. Sous Linux, chaque fichier et dossier a un propriétaire officiel et un groupe. Si vous devez céder la propriété d'un fichier à quelqu'un d'autre (comme l'administrateur système), vous utilisez la commande `chown` (changer de propriétaire). - Étant donné que changer le propriétaire d'un fichier est une action de sécurité sensible, vous devez le préfixer avec `sudo` pour l'exécuter avec des privilèges administratifs. Par exemple, `sudo chown root reports.csv` attribue le fichier à l'utilisateur « root ».

Quête 34Verrouillé

Imaginez vivre dans un immeuble sécurisé où un agent de sécurité se tient à l'entrée pour vérifier les pièces d'identité et bloquer les visiteurs non autorisés. Sous Linux, un **pare-feu** agit comme un agent de sécurité pour vos ports réseau. - La commande `ufw` (Uncomplicated Firewall) est une interface conviviale de gestion des règles de pare-feu. L'exécution de `sudo ufw status` indique si le pare-feu est actif et quels ports (comme le port 22 pour SSH ou le port 80 pour les serveurs Web) sont ouverts. - La commande `iptables` est l'outil Netfilter traditionnel de bas niveau qui bloque ou redirige les paquets. L'exécution de `sudo iptables -L` répertorie les chaînes de sécurité actives et les règles de correspondance de paquets.

Quête 35Verrouillé

In Linux, every process opens three standard I/O streams: - File descriptor `0`: `stdin` (Standard Input) - File descriptor `1`: `stdout` (Standard Output — where normal output goes) - File descriptor `2`: `stderr` (Standard Error — where error messages go) When you run `cmd > output.txt`, only stdout is saved; error messages still appear on your screen. To redirect errors separately, specify file descriptor 2: `cmd 2> errors.log`. To silence noisy errors completely, redirect them to the Linux null device (black hole): `cmd 2> /dev/null`. To combine both stdout and stderr into one stream or file, use `&> output.log` or `cmd > output.log 2>&1`.

Quête 36Verrouillé

In automated scripts and cloud deployment routines (like Dockerfiles or cloud-init), opening an interactive text editor like nano is impossible. Instead, Bash uses **Here-Documents** (`<<EOF`) to inject multi-line blocks of text directly into commands. The syntax `cat <<EOF > config.env` tells the shell to capture all following lines into `config.env` until a line containing only the delimiter word `EOF` is reached.

Quête 37Verrouillé

Whenever a program creates a new file or folder, its initial permissions are determined by the **umask** (user file-creation mode mask). The umask acts as a filter that strips away permissions from maximum defaults (`666` for files, `777` for directories): - Standard umask `022` subtracts group/other write permissions, yielding `644` (`rw-r--r--`) for files and `755` (`rwxr-xr-x`) for folders. - Running `umask 027` tightens security by stripping all permissions from "others", yielding `640` and `750`. To change only the group owner of a file without altering its user owner, use `chgrp <group> <file>`.

Quête 38Verrouillé

Standard file permissions (`rwx`) have three special bits that provide advanced access models: - **Sticky Bit (`+t` or octal `1000`)**: Set on shared directories like `/tmp`. Anyone can create files, but users can only delete or rename files they own. Displayed as `t` in `ls -l` (e.g. `drwxrwxrwt`). - **SUID (Set User ID, `u+s` or octal `4000`)**: When set on an executable binary, standard users run the binary with the file owner's privileges (usually root). Displayed as `s` in owner execute position (e.g. `-rwsr-xr-x`). Essential for tools like `/usr/bin/passwd`. - **Security Auditing**: Attackers frequently abuse SUID binaries for privilege escalation. Sysadmins audit systems for SUID binaries using: `find / -perm -4000 2> /dev/null`.

Quête 39Verrouillé

Standard Linux permissions only support one user owner, one group, and others. When complex enterprise collaboration requires granting distinct rights to multiple users or groups on a single file, **POSIX Access Control Lists (ACLs)** are used: - `getfacl <file>`: Reads and displays the file's extended ACL entries (user, group, mask, other). - `setfacl -m u:<username>:<perms> <file>`: Modifies the ACL to grant specific permissions (`r`, `w`, `x`) to an individual user without changing the file owner. - Notice that when a file has an ACL, `ls -l` displays a `+` symbol at the end of the permission string (e.g., `-rw-rw-r--+`).

👑 Boss · Quête 40Verrouillé

AUDIT FAILURE: An internal compliance scanner raised a critical security finding: `/etc/vault.conf` containing sensitive credentials was deployed with permissive `777` permissions and is owned by `learner` instead of `root`. Remediate the vulnerability immediately by changing the owner of `/etc/vault.conf` to `root:root` and locking down permissions to strict `600` (read/write for owner only). Inspect the file with `ls -l` before and after running your remediation.

5. Superutilisateur et Paquets

Quête 41Verrouillé

Imaginez travailler sur votre ordinateur avec un compte standard pour éviter de supprimer accidentellement des fichiers critiques du système d'exploitation. Lorsque vous devez installer un logiciel ou modifier les paramètres système, votre ordinateur demande une autorisation d'administrateur. Sous Linux, nous utilisons `sudo` (abréviation de « superuser do ») comme carte-clé administrative. - L'utilisateur `root` est le compte administrateur principal avec un contrôle total sur le système. - Les utilisateurs standard ne peuvent pas lire les fichiers sensibles (comme la base de données de mots de passe `/etc/shadow`). En tapant `sudo` avant une commande, vous l'exécutez avec des pouvoirs d'administrateur temporaires pour contourner ces blocages.

Quête 42Verrouillé

Pensez à installer des applications sur votre smartphone via l'App Store ou Google Play Store. Il est sûr, organisé et automatisé. Sous Linux, nous utilisons une boutique d'applications en ligne de commande appelée gestionnaire de packages pour récupérer et installer des logiciels en toute sécurité. - Sur les systèmes Ubuntu/Debian, le gestionnaire de paquets standard est `apt` (Advanced Packaging Tool). - L'installation du logiciel modifie les dossiers à l'échelle du système, vous devez donc toujours l'autoriser en utilisant `sudo`. Par exemple, `sudo apt install tree` télécharge et installe « l’arborescence » du visualiseur d’annuaire.

Quête 43Verrouillé

Avant d'installer un logiciel sous Linux, comment découvrir quels packages sont disponibles dans le référentiel ? Sous Linux, nous utilisons `apt search` pour interroger le catalogue de logiciels par mot-clé. - La commande `apt search <keyword>` analyse les descriptions du référentiel et répertorie les packages logiciels correspondants ainsi que leurs versions. - Contrairement à `apt install`, la recherche dans les référentiels de packages ne lit que les fichiers d'index du catalogue local et ne nécessite **pas** de privilèges de superutilisateur (`sudo`).

Quête 44Verrouillé

Lors de la désinstallation d'un logiciel sous Linux, la norme `apt remove` désinstalle les binaires de l'application mais laisse les fichiers de configuration du système derrière au cas où vous les réinstalleriez ultérieurement. Pour éliminer complètement un progiciel ET effacer tous les fichiers de configuration associés, nous utilisons `apt purge` (ou `apt remove --purge`). - La commande `sudo apt purge <package>` supprime l'application et efface tous les fichiers de configuration restants. - Étant donné que la purge modifie les dossiers et les fichiers de configuration à l'échelle du système, elle nécessite les privilèges de superutilisateur (`sudo`).

Quête 45Verrouillé

Alors que `apt` automatise le téléchargement et la résolution des dépendances de paquets à partir des référentiels, que se passe-t-il si vous avez déjà téléchargé manuellement un fichier de paquet `.deb` et que vous souhaitez l'inspecter ou l'installer ? Sous Linux, nous utilisons `dpkg` (paquet Debian) pour interagir directement avec les packages. - La commande `dpkg -l` répertorie tous les packages actuellement installés sur votre système Debian/Ubuntu. - La commande `dpkg -s <package>` affiche les informations sur l'état, la version et l'architecture d'un package spécifique.

Quête 46Verrouillé

Tous les environnements Linux ne sont pas basés sur Debian/Ubuntu. Si vous travaillez sur des systèmes RedHat, Fedora ou CentOS, vous ne trouverez pas `apt` ou `dpkg`. Au lieu de cela, vous gérerez les packages à l’aide d’anciens gestionnaires de packages `yum` ou modernes `dnf` (Dandified YUM). - La commande `dnf check-update` (ou `yum check-update`) se connecte aux référentiels RedHat pour rechercher les mises à jour de packages disponibles. - La commande `dnf install <package>` récupère et installe des programmes similaires à `apt install`.

Quête 47Verrouillé

New system administrators often confuse updating and upgrading. In Debian and Ubuntu environments: - `sudo apt update`: Refreshes your local cache of package lists from upstream repository servers (`/etc/apt/sources.list`). It discovers which newer package versions exist, but **does not modify or upgrade any software** on disk. - `sudo apt upgrade`: Compares your currently installed software against the refreshed list and downloads/installs the newer package versions. Running `apt upgrade` without running `apt update` first will either install outdated versions or fail completely because your system does not know newer releases exist!

Quête 48Verrouillé

In cross-distribution Linux environments, you will frequently encounter formats beyond Debian `.deb` packages: - **RPM (`rpm`)**: The native package format for RedHat, CentOS, and Fedora. Use `rpm -qa` to list every installed RPM package, and `rpm -qi <package>` to query deep metadata (version, build architecture, signature, description). - **Snap (`snap`)**: Canonical's universal containerized package system. Snaps bundle all dependencies in an isolated sandbox across any Linux distro. Inspect installed snaps with `snap list` and install new tools with `sudo snap install <package>`.

👑 Boss · Quête 49Verrouillé

INCIDENT RESPONSE: An unauthorized script dropped a suspicious unsigned package archive `/tmp/corrupt_pkg.deb` into temporary storage. Furthermore, the standard network diagnostic utility `curl` is missing or unverified in the system catalog. Cleanse the temporary directory by purging `/tmp/corrupt_pkg.deb` and ensure the package manager has `curl` installed and ready for service.

6. Disque et Ressources Système

Quête 50Verrouillé

Imaginez que vous essayiez de télécharger un énorme jeu vidéo et que vous obteniez une erreur « stockage plein », mais vous ne savez pas quel lecteur de disque constitue le goulot d'étranglement. Sous Linux, nous vérifions la capacité de stockage de notre système à l'aide de la commande `df` (disk free). - La commande `df` affiche l'espace total, utilisé et disponible sur tous vos disques connectés. - En exécutant `df -h` (en ajoutant l'indicateur `-h` pour "lisible par l'homme"), vous voyez le stockage en gigaoctets (G) et mégaoctets (M) conviviaux au lieu de confondre le nombre de blocs, ce qui permet de repérer facilement quel lecteur (comme `/` ou `/home`) est plein. **Pourquoi est-ce important** : Si vous exécutez `df` sans `-h`, les tailles sont affichées sous forme de nombres bruts de blocs de 1 000 (par exemple, `49258284` au lieu de `47G`), ce qui est extrêmement difficile à lire et à calculer pour un humain. L'indicateur `-h` formate ces tailles en gigaoctets (G) et mégaoctets (M) conviviaux.

Quête 51Verrouillé

Une fois que vous savez *quel* lecteur est plein, comment trouvez-vous le dossier spécifique qui occupe tout votre espace ? Est-ce votre dossier de téléchargements, ou peut-être un cache caché ? Nous résolvons ce mystère en utilisant la commande `du` (utilisation du disque). - `du <directory>` répertorie la taille d'un dossier et de chaque sous-dossier qu'il contient. - `du -sh <directory>` (où `-s` signifie « résumé » et `-h` signifie « lisible par l'homme ») calcule et imprime une taille totale unique et propre pour ce dossier spécifique. **Pourquoi est-ce important** : Si vous exécutez `du` sans `-s`, il affichera un énorme mur de texte répertoriant chaque sous-répertoire et fichier de manière récursive, plutôt que de donner un seul résumé. L'indicateur `-s` résume la taille totale du dossier et `-h` le rend lisible par l'homme.

Quête 52Verrouillé

Imaginez que votre ordinateur portable commence à prendre du retard, que les pages Web se figent et que le changement d'application semble extrêmement lent. Cela signifie généralement que votre ordinateur manque de mémoire active (RAM). Sous Linux, nous pouvons vérifier la marge de manœuvre dont dispose notre système à l’aide de la commande `free`. - La commande `free` affiche la mémoire physique (RAM) et l'espace d'échange total, utilisés et disponibles. - L'ajout de l'indicateur `-h` (exécutant `free -h`) formate la taille de la mémoire en gigaoctets (Go) et mégaoctets (Mo) faciles à lire afin que vous puissiez savoir si un programme consomme toutes vos ressources. **Pourquoi est-ce important** : Si vous exécutez `free` sans `-h`, l'utilisation de la mémoire est imprimée en kilo-octets bruts (par exemple, `16323456` au lieu de `16G`), ce qui est difficile à interpréter rapidement. L'indicateur `-h` met automatiquement à l'échelle les nombres en gigaoctets (G) ou en mégaoctets (M) pour une lecture facile.

Quête 53Verrouillé

Imaginez dépanner un serveur qui a commencé à mal se comporter et avoir besoin de savoir s'il a récemment redémarré, ou vérifier exactement quelle version du système d'exploitation s'exécute sous le capot. Nous pouvons interroger ces détails du système en quelques secondes : - La commande `uptime` vous indique exactement combien de temps votre machine a fonctionné depuis son dernier démarrage, ainsi que son niveau d'activité (charge système). - La commande `uname -a` (nom Unix) imprime un rapport complet du noyau de votre système, du nom de la plate-forme et de l'architecture de la machine. **Pourquoi est-ce important** : Si vous exécutez `uname` sans `-a`, il affiche uniquement le nom de base du système d'exploitation (par exemple, `Linux`). Il laisse de côté des détails critiques tels que la version du noyau, le nom de la plate-forme et l'architecture du processeur. L'indicateur `-a` imprime tous les détails du système disponibles dans un seul rapport.

Quête 54Verrouillé

Lors du dépannage des performances du système ou du déploiement d'applications très demandées, vous devez connaître les capacités du processeur de votre système. Sous Linux, nous lisons des informations détaillées sur l'architecture du processeur à l'aide de la commande `lscpu`. - La commande `lscpu` affiche les détails du processeur tels que le modèle du processeur, le fournisseur, la vitesse d'horloge, le nombre de cœurs, les détails de l'hyper-threading et la taille du cache, directement à partir du système de fichiers du noyau.

Quête 55Verrouillé

Lorsqu'une base de données ou une application Web s'exécute lentement, comment déterminer si le problème est un goulot d'étranglement du processeur ou un disque dur lent ? Sous Linux, nous surveillons les métriques de performances de sortie/entrée du système à l’aide de `iostat`. - La commande `iostat` affiche des statistiques de rapport sur l'utilisation du processeur et le débit de lecture/écriture du périphérique actif, vous aidant ainsi à identifier la congestion du disque.

Quête 56Verrouillé

Before a disk can store files, it is divided into storage blocks and partitions formatted with filesystems. In Linux: - `lsblk`: Lists block storage devices (hard drives, NVMe SSDs, flash drives) in an intuitive tree showing parent drives (like `sda`, `sdb`), child partitions (like `sda1`, `sdb1`), sizes, and active mountpoints. Adding `-f` shows filesystem types and UUIDs. - `sudo blkid`: Queries disk headers directly to print device Universally Unique Identifiers (UUIDs), filesystem formats (such as `ext4`, `xfs`, `vfat`), and partition labels used in boot and mount configurations.

Quête 57Verrouillé

In Unix systems, disk drives do not have isolated drive letters like `C:\` or `D:\`. Instead, all filesystems attach into a unified directory tree: - `sudo mount <device> <directory>`: Attaches a formatted block partition (e.g. `/dev/sdb1`) into an existing directory folder (the "mountpoint", e.g. `/mnt/data`). - `sudo umount <directory>`: Safely detaches the filesystem, committing unwritten buffers to disk before unplugging or reformatting. - `/etc/fstab`: The static filesystem table file describing which partitions automatically mount at boot time, their mount options, and dump/fsck pass priorities.

Quête 58Verrouillé

When hardware devices attach, drives fail, or the Linux kernel encounters system memory exhaustion, kernel messages are written to a special memory area called the **Kernel Ring Buffer**. - `dmesg`: Dumps raw kernel boot and runtime log messages. - `dmesg -T`: Converts raw timestamps into readable date and time strings. - Pipelining `dmesg | grep -i error` or filtering for "Out of memory" reveals low-level driver failures and Out-Of-Memory (OOM) killer terminations.

👑 Boss · Quête 59Verrouillé

CRITICAL ALERT: Root filesystem capacity has hit 99%! Production monitoring reports that an unhandled core dump `/var/log/huge_core_dump.log` is suffocating system storage. Locate the runaway file, delete `/var/log/huge_core_dump.log` to reclaim space, and create a status confirmation log `/home/learner/disk_recovery.txt` containing a summary of recovered capacity.

7. Gestion des Processus

Quête 60Verrouillé

Considérez votre système d'exploitation comme un bureau occupé où chaque employé (ou programme en cours d'exécution) se voit attribuer un nom unique appelé ID de processus (PID). Sous Linux, nous appelons ces programmes actifs **processus** et nous les listons à l'aide de la commande `ps`. - L'exécution de `ps` seul affiche uniquement les programmes exécutés dans la fenêtre de votre terminal actuelle. - L'exécution de `ps aux` agit comme un registre de bureau principal, répertoriant chaque programme actif exécuté sur l'ensemble du système, qui l'a démarré et la quantité de processeur et de mémoire qu'il utilise. **Pourquoi est-ce important** : Si vous exécutez `ps` sans `aux`, vous ne verrez que les processus en cours d'exécution dans la fenêtre de votre terminal actuelle (généralement juste `bash` et `ps` lui-même). Vous ne verrez pas les services d'arrière-plan, les processus système ou les programmes exécutés par d'autres utilisateurs. Les options `aux` révèlent tous les processus en cours d'exécution à l'échelle du système.

Quête 61Verrouillé

Imaginez regarder une photo statique d'une autoroute plutôt que de regarder le flux d'une caméra de trafic en direct. Alors que `ps` vous donne un aperçu rapide de ce qui est en cours d'exécution, `top` vous permet de regarder les performances de votre système en direct. - La commande `top` lance un tableau de bord interactif en temps réel qui se met à jour toutes les quelques secondes. Il affiche l'utilisation du processeur, les moyennes de charge et classe dynamiquement les processus les plus gourmands en ressources en cours d'exécution à ce moment précis.

Quête 62Verrouillé

Dans les systèmes de type Unix, « tout est un fichier ». Cela signifie que non seulement les fichiers texte et les dossiers, mais également les sockets réseau, le matériel système et les processus sont traités comme des fichiers. Pour savoir quels fichiers sont consultés par quels programmes en cours d'exécution, nous utilisons `lsof` (List Open Files). - L'exécution de `lsof` affiche une liste complète de tous les fichiers ouverts, ainsi que l'ID de processus (PID) et la commande qui les a ouverts. - Par exemple, exécuter `lsof -i` répertorie tous les fichiers/sockets réseau, ce qui est extrêmement utile pour découvrir quel processus écoute sur un port réseau spécifique (comme le port 80).

Quête 63Verrouillé

Imaginez qu'une application sur votre téléphone se bloque, verrouillant complètement votre écran, et que vous deviez la fermer de force pour que tout fonctionne à nouveau correctement. Sous Linux, nous arrêtons les programmes qui se comportent mal ou sont gelés en utilisant la commande `kill` suivie de l'ID de processus (PID) du programme. - L'exécution de `kill 1234` envoie une demande polie demandant au programme de sauvegarder son travail et de se fermer. - S'il est gelé et ignore la demande polie, `kill -9 1234` force le système d'exploitation à l'arrêter instantanément. Nous sommes confrontés à un processus incontrôlable avec le PID `9999` qui monopolise tout notre processeur en ce moment : arrêtons-le !

Quête 64Verrouillé

Imaginez que vous essayez de copier un dossier volumineux sur une clé USB, mais que pendant la copie, vous souhaitez continuer à travailler et à taper d'autres commandes dans la même fenêtre. Sous Linux, nous pouvons exécuter des tâches fastidieuses en « arrière-plan » afin qu'elles ne bloquent pas notre ligne de commande. - L'ajout d'une esperluette `&` à la fin d'une commande (comme `sleep 100 &`) indique au terminal de l'exécuter en arrière-plan et de vous renvoyer immédiatement votre invite. - La commande `jobs` montre ce qui s'exécute actuellement en arrière-plan. - La commande `fg` (premier plan) ramène une tâche en arrière-plan au centre de la scène.

Quête 65Verrouillé

Dans un bureau occupé, certaines tâches peu prioritaires (comme le dépôt des reçus) peuvent attendre, tandis que les demandes hautement prioritaires doivent être traitées immédiatement. Linux gère la priorité des processus en utilisant des valeurs de **gentilesse** allant de -20 (priorité la plus élevée) à 19 (priorité la plus basse). - La commande `nice` lance un traitement avec une priorité personnalisée. Par ex. `nice -n 10 sleep 5` démarre une commande sleep avec une priorité polie de 10. - La commande `renice` modifie la priorité de planification d'un processus déjà en cours d'exécution. Par exemple, `sudo renice +5 9999` réduit la priorité du processus 9999.

Quête 66Verrouillé

Nous avons déjà vu comment démarrer une tâche en arrière-plan en utilisant `&` et la relancer en utilisant `fg`. Mais que se passe-t-il si vous démarrez une commande sans `&` ou si vous la suspendez avec `Ctrl+Z` ? Vous pouvez le reprendre en arrière-plan en utilisant `bg` ! - La commande `bg` reprend les tâches suspendues, leur permettant de s'exécuter en arrière-plan sans bloquer l'invite de votre terminal.

Quête 67Verrouillé

In fast-paced system operations, looking up process IDs with `ps aux | grep name` just to pass a numerical PID into `kill` is slow and error-prone. Linux provides process lookup and signal tools that operate directly by process name: - `pgrep <pattern>`: Scans active processes and returns matching PIDs. Adding `-a` outputs the full command line alongside the PID. - `pkill <pattern>`: Sends termination signals directly to all processes matching the pattern (e.g. `pkill -9 miner`). - `killall <name>`: Kills processes matching the exact binary executable name.

Quête 68Verrouillé

Long-running tasks need two critical abilities: surviving unexpected network disconnects, and real-time execution monitoring without manual re-typing: - `nohup <command> &`: Runs a command immune to SIGHUP (hangup signals). If your SSH session drops or terminal closes, the program continues executing in the background, redirecting stdout/stderr into `nohup.out`. - `watch -n <seconds> <command>`: Repeatedly executes a command at a set interval (default 2s), clearing the screen to display a live updating dashboard of system state.

👑 Boss · Quête 69Verrouillé

SERVER THROTTLED: CPU load average has spiked above 25.0. An unauthenticated background script (PID 9999 running `rogue_process.sh`) is monopolizing 99.1% of processor cycles and starving application threads. Inspect the active process table to discover the rogue PID, determine its signal tolerance, and kill the process immediately so it ceases execution.

8. Dépannage Réseau

Quête 70Verrouillé

Imaginez que vous essayez de charger une page Web, mais que votre navigateur tourne sans fin, vous laissant vous demander si le Wi-Fi de votre maison est déconnecté ou si le site Web lui-même est tombé en panne. Sous Linux, nous testons notre connexion réseau de base à l'aide de la commande `ping`. - La commande `ping` envoie de minuscules paquets de données à un serveur (comme `google.com`) et mesure le nombre de millisecondes nécessaires pour recevoir une réponse. - Sous Linux, `ping` continuera à fonctionner indéfiniment par défaut. Pour l'arrêter après quelques tentatives, nous utilisons l'indicateur `-c` (count), exécutant `ping -c 3 google.com`. **Pourquoi est-ce important** : Si vous exécutez `ping google.com` sans `-c`, il continuera à envoyer des paquets et à imprimer les résultats à l'infini. Vous devrez l'interrompre manuellement avec `Ctrl+C` pour exécuter d'autres commandes. L'indicateur `-c 3` arrête automatiquement la commande après l'envoi d'exactement 3 paquets.

Quête 71Verrouillé

Imaginez configurer une imprimante réseau ou partager des fichiers avec l'ordinateur d'un ami sur le même réseau Wi-Fi et avoir besoin de connaître l'adresse IP locale de votre machine. Sous Linux, nous inspectons notre matériel réseau et nos adresses IP à l'aide de la commande `ip`. - L'exécution de `ip addr` (ou simplement `ip a`) imprime une liste de tous vos périphériques d'interface réseau (comme `eth0` pour Ethernet filaire ou `wlan0` pour sans fil) ainsi que leurs adresses IP locales attribuées.

Quête 72Verrouillé

Avant que la suite de commandes moderne `ip` ne devienne standard, les administrateurs système Linux s'appuyaient sur `ifconfig` (configurateur d'interface) pour afficher et gérer les interfaces réseau. - La commande `ifconfig` affiche les interfaces réseau actives, la configuration IP locale, les détails du masque de réseau et les adresses matérielles MAC. Bien que obsolète sur certaines distributions plus récentes, il reste largement utilisé sur les serveurs existants.

Quête 73Verrouillé

Sur les postes de travail et serveurs Linux modernes, les interfaces réseau sont gérées par un démon système appelé NetworkManager. Plutôt que de modifier manuellement les fichiers de configuration, nous configurons les détails du réseau à l'aide de `nmcli`. - La commande `nmcli` (NetworkManager CLI) vous permet d'inspecter les connexions matérielles, les états des appareils et les réseaux Wi-Fi actifs.

Quête 74Verrouillé

Lors de la configuration d'une base de données ou d'un serveur Web, vous devez vérifier que le service est en cours d'exécution et écoute sur le bon port, et vérifier si des connexions non autorisées sont établies. Nous faisons cela en utilisant `netstat` ou `ss`. - La commande `netstat` (statistiques réseau) est un outil classique pour afficher les connexions TCP et les ports d'écoute. Par ex. `netstat -tuln` répertorie les ports d'écoute TCP/UDP. - La commande `ss` (statistiques de socket) est l'alternative moderne et plus rapide à `netstat` qui affiche les détails de connexion du socket directement à partir de l'espace de noms du noyau.

Quête 75Verrouillé

Lorsqu'une page Web ne parvient pas à se charger, comment identifier si le problème vient de votre routeur domestique, de votre fournisseur d'accès Internet (FAI) ou du serveur de destination ? Sous Linux, nous traçons les paquets en utilisant `traceroute`. - La commande `traceroute` répertorie chaque passerelle de routeur (saut) qu'un paquet traverse pour se diriger vers un serveur distant, ainsi que la latence de réponse pour chaque saut.

Quête 76Verrouillé

Imaginez vouloir télécharger un fichier ou récupérer le code d'un script d'installation directement à partir d'un serveur Web sans ouvrir de navigateur et cliquer sur un bouton "Télécharger". Sous Linux, nous récupérons les données Web en utilisant `curl` (abréviation de « Client URL »). - L'exécution de `curl <url>` télécharge le contenu de la page et l'imprime directement sur votre écran. - Pour enregistrer le contenu téléchargé sous forme de fichier au lieu de l'afficher, nous l'associons à la redirection `>` ou à l'indicateur de sortie `-o`.

Quête 77Verrouillé

When your machine translates a human-readable domain name like `example.com` into an IP address like `93.184.216.34`, it queries DNS nameservers configured in `/etc/resolv.conf`. - `/etc/resolv.conf`: Contains your system's primary and fallback DNS nameservers. - `dig <domain>`: The de-facto standard administrator tool for testing DNS queries, returning response headers, query latency, and record TTLs. Adding `+short` prints only the final IP answer. - `nslookup <domain>` and `host <domain>`: Lightweight queries for checking A/AAAA and MX mail exchange records.

Quête 78Verrouillé

When your server sends a packet to an IP address outside its local subnet, how does the kernel know which router or network card interface to send it through? It consults the **Kernel IP Routing Table**. - `ip route` (or `ip r` / `ip ro`): Displays active routing table entries. - The line starting with `default via <IP> dev <interface>` defines your **Default Gateway** (your router), which handles all internet traffic not addressed to a local subnet.

Quête 79Verrouillé

Two everyday network maintenance tasks are testing whether remote ports are open and downloading files without browsers: - `nc` (Netcat): Often called the "Swiss Army Knife" of TCP/IP. Running `nc -zv <host> <port>` scans a target port without sending application data (`-z` for zero-I/O port scanning, `-v` for verbose output), instantly confirming if a firewall or service is responding. - `wget`: The robust non-interactive network downloader. Running `wget -O <output-file> <url>` downloads files reliably, resuming broken connections.

Quête 80Verrouillé

Every computer on a network possesses a hostname that identifies it to other machines and shell prompts (e.g., `learner@bashquest:~$`). In modern systemd environments: - `hostname`: Displays the current simple system hostname. - `hostnamectl`: Displays complete system identification metadata, including operating system release, kernel build version, hardware chassis, and virtualization hypervisor. - `sudo hostnamectl set-hostname <name>`: Persistently updates the hostname across reboots by modifying `/etc/hostname` and updating the systemd hostnamed daemon.

👑 Boss · Quête 81Verrouillé

SECURITY COMPROMISE: An attacker injected a DNS poisoning entry `0.0.0.0 evil-tracker.local` directly into `/etc/hosts`, corrupting internal hostname resolution. Remediate the threat: edit or clean `/etc/hosts` to remove all references to `evil-tracker.local`, and record `evil-tracker.local` in `/etc/blocked_hosts.conf` so the domain is permanently logged for network blacklisting.

9. Recherche de Fichiers

Quête 82Verrouillé

Imaginez égarer un fichier texte important quelque part dans votre dossier utilisateur et devoir rechercher un par un dans des dizaines de répertoires imbriqués. Sous Linux, nous contournons la recherche manuelle en utilisant l'utilitaire `find` comme moteur de recherche ultra-rapide à l'échelle du système. - La commande `find` recherche dans les arborescences de répertoires en fonction du nom, de la taille, du type ou de la date. - La syntaxe est `find <where> -name "<pattern>"`. Par exemple, `find . -name "*.txt"` recherche dans le répertoire actuel et dans tous les sous-dossiers les fichiers se terminant par `.txt`. **Pourquoi est-ce important** : Si vous exécutez `find . "*.log"` sans `-name`, vous obtiendrez l'erreur : `find: paths must precede expression: '*.log'`. L'indicateur `-name` est requis pour spécifier que le modèle suivant doit être comparé aux noms de fichiers.

Quête 83Verrouillé

Imaginez que vous ayez tapé une commande de diagnostic réseau longue et complexe il y a dix minutes et que vous deviez maintenant l'exécuter à nouveau, mais que vous ne vous souvenez plus des options ou de la syntaxe exactes. Au lieu de vous gratter la tête ou de tout taper partout, Linux s'en souvient pour vous ! - La commande `history` affiche une liste numérotée de toutes les commandes que vous avez récemment exécutées. - Vous pouvez réexécuter rapidement n'importe quel élément en tapant un point d'exclamation suivi de son numéro de liste (comme `!42` pour réexécuter la commande n°42).

Quête 84Verrouillé

Imaginez que vous essayez d'utiliser une nouvelle commande, mais que vous n'êtes pas sûr des indicateurs qu'elle prend en charge ni de la façon dont ses entrées doivent être formatées. Au lieu de chercher en ligne, Linux dispose d'un manuel d'utilisation officiel et complet intégré directement au terminal ! - La commande `man` (manuel) suivie de n'importe quel nom d'utilitaire (par exemple, `man ls`) ouvre un guide de référence détaillé. - Dans le guide, faites défiler avec les touches fléchées, recherchez avec "/" et appuyez sur `q` pour fermer le manuel et revenir à votre invite.

Quête 85Verrouillé

Beyond basic filename queries, `find` is a powerhouse filter engine for automated system cleanup and log rotation: - `-size +50M`: Filters for files strictly larger than 50 Megabytes (`+` for greater than, `-` for less than). - `-mtime -7`: Filters for files modified within the last 7 days. - `-exec <cmd> {} +`: Passes all matched files directly into a command in batches, replacing `{}` with matched file paths. Combining these allows single-line system maintenance, such as finding and purging runaway logs: `find /var/log -size +50M -exec rm {} +`.

Quête 86Verrouillé

When `find` is too slow because it scans the live disk tree, and you need to inspect command binaries vs shell builtins: - `sudo updatedb`: Crawls the entire filesystem and builds a high-speed precomputed search index database (`mlocate.db`). - `locate <name>`: Instantly searches the indexed database in milliseconds instead of seconds. - `whereis <cmd>`: Locates binary executables, source files, and man pages in standard system paths. - `type <name>`: Identifies whether a command is a shell builtin (e.g. `cd`, `umask`), an alias (e.g. `ll`), or an external binary disk file (e.g. `/bin/ls`).

Quête 87Verrouillé

When you know what task you want to achieve, but don't remember the exact Linux command name, or when you need a quick one-line summary of what an unfamiliar command does: - `apropos <keyword>`: Searches through the short one-line description summaries of **all manual pages** on the system, returning any command related to that concept (e.g. `apropos partition`, `apropos process`). - `whatis <cmd>`: Displays the exact single-line summary from section 1 or 8 of that specific tool's manual page (e.g. `whatis ls`, `whatis grep`).

👑 Boss · Quête 88Verrouillé

DISASTER RECOVERY: Before an unexpected reboot, a database administrator saved an encrypted backup archive named `db_backup_secure.tar.gz`, but failed to document its path. It is lost somewhere on the filesystem. Locate the misplaced archive file anywhere across the system hierarchy, and restore it to its designated safe haven: copy it to `/home/learner/backups/db_backup_secure.tar.gz`.

10. Services et Systemd

Quête 89Verrouillé

Imaginez que vous hébergez un site Web sur votre ordinateur, mais que les visiteurs reçoivent une erreur « Le site n'est pas accessible » car le programme du serveur Web en arrière-plan ne s'exécute pas. Sous Linux, les processus d'arrière-plan qui démarrent automatiquement et s'exécutent en arrière-plan (comme les bases de données, les pare-feu ou les serveurs Web) sont appelés **services** et nous les gérons à l'aide de `systemctl`. - La commande `systemctl status <service>` vérifie si un service est actif ou arrêté. - Étant donné que le démarrage ou l'arrêt d'un service affecte tous les utilisateurs et la sécurité du système, vous devez utiliser `sudo` pour exécuter des commandes comme `sudo systemctl start <service>` ou `sudo systemctl stop <service>`.

Quête 90Verrouillé

Maintenant que vous pouvez démarrer et arrêter les services en arrière-plan avec `systemctl`, comment les dépanner en cas de panne ? L'utilitaire `journalctl` vous permet d'inspecter les journaux système générés par les services gérés par systemd. - Par défaut, `journalctl` affiche tous les journaux système. Parce que cela peut être massif, nous les filtrons pour rester concentrés. - L'option `-u <service>` filtre les journaux pour afficher uniquement les messages d'un service spécifique (par exemple `journalctl -u apache2`). - L'option `-n <number>` affiche uniquement les entrées les plus récentes (par exemple `journalctl -n 5` pour les 5 derniers journaux). - L'indicateur `-f` (suivre) affiche les journaux en temps réel au fur et à mesure de leur écriture.

Quête 91Verrouillé

Starting a service with `systemctl start` only launches it for the current session. If the server reboots, the service will stay offline unless you configure it to start automatically on system initialization. - To start a service at boot, run `sudo systemctl enable <service>`. - To verify whether a service is scheduled to launch at boot, run `systemctl is-enabled <service>`. - When creating or editing systemd unit files, always notify systemd to reload its configuration cache with `sudo systemctl daemon-reload`. - To disable a service from starting at boot, run `sudo systemctl disable <service>`.

Quête 92Verrouillé

Accurate system time is critical for log auditing, authentication protocols (Kerberos, TLS certificates), and scheduled database backups. - The `timedatectl` utility queries and changes the system clock and its timezone. - View the current time settings, RTC, and active timezone with `timedatectl status` (or simply `timedatectl`). - Set the system timezone using superuser rights: `sudo timedatectl set-timezone UTC`. - When shutting down or restarting production servers, use the `shutdown` command with safety delays and broadcast notices: `sudo shutdown -r now` (reboots immediately) or `sudo shutdown -c` (cancels scheduled shutdowns).

👑 Boss · Quête 93Verrouillé

OUTAGE REPORT: The primary HTTP frontend service `apache2.service` crashed and is currently in an `inactive (dead)` state. Client web requests are timing out. Inspect the service status with your service management tools, discover the problem, and use `systemctl` with superuser privileges to restart or start `apache2` so it returns to `active (running)`.

11. Édition de Texte dans le Terminal

Quête 94Verrouillé

Imaginez une connexion SSH sur un serveur cloud distant sur lequel vous n'avez pas de bureau graphique ni de curseur et où vous devez rapidement corriger une ligne dans un fichier de configuration. Dans ces scénarios, vous devez utiliser un éditeur de texte de terminal tel que `nano`. - L'exécution de `nano <filename>` charge un éditeur de texte simple et léger directement dans la fenêtre de votre shell. - Les raccourcis sont toujours affichés en bas de l'écran : appuyez sur `Ctrl+O` pour écrire (enregistrer) vos modifications, et `Ctrl+X` pour quitter l'éditeur.

Quête 95Verrouillé

Vim is one of the most powerful and ubiquitous terminal text editors in Linux. Unlike traditional graphical editors, Vim is **modal**: - **Normal Mode**: The default mode used for navigation, deleting, and issuing commands. - **Insert Mode**: The mode used for typing text. Press `i` from Normal Mode to start typing. - **Return to Normal Mode**: Press `Esc` at any time to leave Insert Mode. - **Command-Line Mode**: From Normal Mode, press `:` to type commands at the bottom prompt: - `:w` writes (saves) the file. - `:q` quits the editor. - `:wq` (or `:x`) saves and exits in one step. - `:q!` quits immediately, discarding all unsaved changes.

Quête 96Verrouillé

Once you master Normal mode commands, Vim allows lightning-fast text manipulation without touching a mouse: - `dd`: Delete (cut) the entire current line into the yank buffer. - `yy`: Yank (copy) the current line. - `p`: Paste the yank buffer on the line below the cursor. - `/pattern`: Search forward through the file for text matching `pattern`. - `:%s/old/new/g`: Global search and replace throughout the entire file without manual edits.

👑 Boss · Quête 97Verrouillé

CONFIGURATION CORRUPTION: A late-night config commit broke `/home/learner/server.conf`. The file contains invalid directives: `host=0.0.0.0.0` (malformed IP) and `port=99999` (outside the 1-65535 port range). Open `/home/learner/server.conf` with your text editor (nano, vim, or shell tools) and correct the file so that `host=127.0.0.1`, `port=80`, and `max_connections=500` are set.

12. Scripts Shell et Automatisation

Quête 98Verrouillé

Imaginez avoir une liste de 20 tâches que vous devez exécuter chaque matin. Les saisir manuellement est fastidieux et laisse place aux fautes de frappe. Sous Linux, nous regroupons les commandes dans un fichier appelé script shell afin de pouvoir les exécuter toutes en même temps ! - Chaque script commence par un "shebang" (`#!/bin/bash`) sur la toute première ligne pour indiquer au système quel interpréteur shell utiliser pour exécuter le fichier. - Après avoir enregistré votre script, vous le rendez exécutable en lui accordant l'autorisation d'exécution via `chmod 755 script.sh` puis en l'exécutant avec `./script.sh`.

Quête 99Verrouillé

Imaginez créer un message de bienvenue personnalisé pour un site Web. Vous ne voudriez pas écrire un script distinct pour le nom de chaque client ! Au lieu de cela, vous écrivez un script qui prend un nom en entrée lorsque vous l'exécutez. - Dans les scripts bash, les variables comme `$1`, `$2`, etc. contiennent les "arguments" ou les entrées que vous transmettez sur la ligne de commande. - Par exemple, exécuter `./greet.sh Alice` signifie que `$1` à l'intérieur du script contiendra automatiquement le texte "Alice". De même, `$#` garde une trace du nombre d'entrées fournies par l'utilisateur.

Quête 100Verrouillé

Imaginez créer un script qui traite un rapport CSV, mais il plante si le fichier de rapport n'existe pas réellement sur le disque. Pour éviter les erreurs, nous écrivons des scripts qui prennent des décisions en utilisant la logique conditionnelle `if/else`. - Nous vérifions les conditions à l'aide de parenthèses : `if [ -f "$1" ]; then ... fi`. - L'indicateur `-f` vérifie si un chemin pointe vers un fichier, tandis que `-d` vérifie s'il s'agit d'un répertoire. Le script divise ses actions selon que la condition est évaluée comme vraie ou fausse.

Quête 101Verrouillé

Imaginez avoir un dossier de 100 fichiers journaux et vous devez faire une copie de sauvegarde de chacun d'entre eux. Les copier individuellement serait épuisant. Sous Linux, nous utilisons les boucles `for` pour répéter automatiquement la même action sur toute une liste d'éléments ! - Une boucle `for` (comme `for file in *.txt; do ... done`) parcourt chaque élément qui correspond à un modèle, les traitant l'un après l'autre en une fraction de seconde.

Quête 102Verrouillé

Vous avez écrit des boucles et des conditions pour automatiser les actions dans les scripts. Mais à mesure que vos scripts se développent, copier-coller la même logique encore et encore rend leur maintenance difficile. En bash, nous pouvons regrouper les commandes en fonctions réutilisables. - Pour définir une fonction, on la déclare par son nom suivi de parenthèses et d'accolades : `log_msg() { echo "msg"; }`. - Les fonctions peuvent recevoir des arguments tout comme les scripts shell, auxquels on accède à l'aide des paramètres de position locale `$1`, `$2`, etc. à l'intérieur du corps de la fonction. - Pour appeler une fonction, utilisez simplement son nom comme n'importe quelle autre commande : `log_msg "Backup started"`.

Quête 103Verrouillé

Maintenant que vous avez écrit des scripts shell robustes, vous ne voudriez pas vous connecter à minuit juste pour exécuter votre assistant de sauvegarde. Linux fournit le service `cron` pour exécuter automatiquement des commandes ou des scripts à des moments précis. - Le service cron vérifie une table de planification appelée `crontab`. - Chaque planning cron comporte 5 champs représentant l'heure : `minute hour day-of-month month day-of-week` suivi de la commande. - Par exemple, `30 2 * * * /path/to/script.sh` exécute un script tous les jours à 2h30. - Nous utilisons `crontab -l` pour lister nos tâches cron actives et `crontab <filename>` pour charger les plannings à partir d'un fichier.

Quête 104Verrouillé

Every command executed in Linux returns an **exit status code** between 0 and 255 upon completion: - `0`: Success (no errors occurred). - `1-255`: Failure or error code. - The special shell parameter `$?` stores the exit code of the immediately preceding command: `echo $?`. Shell logic operators chain commands based on exit codes: - `cmd1 && cmd2`: Logical AND. Runs `cmd2` **only if** `cmd1` succeeds (exit code 0). - `cmd1 || cmd2`: Logical OR. Runs `cmd2` **only if** `cmd1` fails (non-zero exit code). Combining them creates clean resilient commands: `mkdir backup && cp app.db backup/ || echo "Backup failed"`.

Quête 105Verrouillé

Interactive and automated scripts rely on two essential shell capabilities: 1. **User Input (`read`)**: Prompts the user to enter data and stores the response in a shell variable. The `-p` flag prints a custom prompt string: `read -p "Enter username: " USERNAME` 2. **Command Substitution (`$(...)`)**: Executes a command in a subshell and substitutes its standard output into the variable or command line: `TODAY=$(date +%F)` This lets you create dynamic timestamped filenames and automated reports.

Quête 106Verrouillé

Two of the most common control structures in systems engineering scripts are file-reading loops and case branches: 1. **File-reading `while` loop**: Reads input line by line safely using `read -r` without interpreting escape characters: `while read -r line; do echo "Processing: $line"; done < names.txt` 2. **`case` statement**: Matches a variable against multiple patterns cleaner than multiple `if/elif` blocks: `case $1 in start) systemctl start app ;; stop) systemctl stop app ;; *) echo "Usage: $0 {start|stop}" ;; esac`

👑 Boss · Quête 107Verrouillé

OPERATIONAL REQUIREMENT: Deploy an automated system health-check script at `/home/learner/healthcheck.sh`. The script must be a valid executable Bash script containing the `#!/bin/bash` shebang on line 1, must output the token `SYSTEM_OK`, and must have executable permissions (`755` or `rwxr-xr-x`) so monitoring agents can invoke it directly without errors.

13. Traitement de Texte Avancé

Quête 108Verrouillé

Imaginez que vous ayez un énorme fichier de vidage de base de données et que vous deviez remplacer toutes les occurrences d'une ancienne adresse IP de serveur par une nouvelle. L'ouvrir dans un éditeur peut geler votre ordinateur. Sous Linux, nous éditons les flux de texte à la volée en utilisant `sed` (abréviation de « éditeur de flux »). - La syntaxe de base est `sed "s/old/new/g" file.txt` pour rechercher et remplacer du texte. - L'ajout de l'indicateur `-i` (sur place) enregistre les remplacements directement dans le fichier lui-même, plutôt que de simplement imprimer le texte modifié à l'écran. **Pourquoi est-ce important** : Si vous exécutez `sed "s/port=80/port=8080/g" server.conf` sans `-i`, il imprimera uniquement le texte modifié sur l'écran de votre terminal. Le fichier réel reste complètement inchangé. L'indicateur `-i` (sur place) est nécessaire pour enregistrer les modifications directement dans le fichier.

Quête 109Verrouillé

Imaginez recevoir une grande feuille de calcul enregistrée sous forme de texte brut, où les colonnes sont séparées par des virgules ou des espaces, et vous n'avez besoin d'extraire que la toute première colonne de données. Sous Linux, nous analysons des colonnes de texte structurées à l'aide du langage puissant `awk`. - Par défaut, `awk` divise les lignes par espaces, en attribuant la colonne 1 à `$1`, la colonne 2 à `$2`, et ainsi de suite. - L'indicateur `-F` vous permet de spécifier un séparateur personnalisé (comme `-F:` pour les deux-points). Par exemple, `awk -F: '{print $1}' /etc/passwd` extrait uniquement les noms d'utilisateur d'une liste séparée par deux points. **Pourquoi est-ce important** : Si vous exécutez `awk '{print $1}' /etc/shadow` sans `-F:`, `awk` divisera les lignes par des espaces (valeur par défaut) plutôt que par des deux-points. Étant donné que les lignes du fichier fantôme ne comportent pas d'espaces, la ligne entière est traitée comme un seul champ, imprimant les détails de hachage complets de chaque utilisateur. L'indicateur `-F:` force `awk` à diviser les colonnes par deux-points à la place.

Quête 110Verrouillé

Imaginez travailler avec une feuille de calcul CSV contenant les dates et les noms des transactions. Vous souhaitez extraire uniquement la première colonne (dates) et convertir tout le texte en majuscules pour plus de cohérence. Sous Linux, nous pouvons combiner des outils d'analyse légers dans un pipeline : - La commande `cut` découpe des colonnes spécifiques du texte structuré. Par exemple, `cut -d, -f1` divise les lignes par des virgules (`-d,`) et extrait la première colonne (`-f1`). - La commande `tr` (traduire) transforme les caractères de l'entrée standard, comme en échangeant des caractères minuscules contre des majuscules (`tr "a-z" "A-Z"`). **Pourquoi est-ce important** : Si vous exécutez `cut reports.csv` sans `-d,` et `-f1`, vous obtiendrez : `cut: you must specify a list of bytes, characters, or fields`. Si vous spécifiez `-f1` mais omettez `-d,`, la valeur par défaut est des onglets, ce qui signifie qu'il ne divisera pas un fichier CSV et imprimera simplement la ligne entière. L'indicateur `-d,` définit la virgule comme séparateur de colonne et `-f1` lui indique d'extraire uniquement la première colonne.

Quête 111Verrouillé

Modern cloud infrastructure, Kubernetes, Docker, and REST APIs all communicate in JSON. The `jq` command-line JSON processor is the industry standard tool for slicing, filtering, and mapping structured JSON data in terminal pipelines. - Pretty-print and syntax validate JSON: `cat api.json | jq '.'` (or `jq '.' api.json`). - Extract specific keys: `jq '.version' api.json`. - Access array items and nested object fields: `jq '.users[0].name' api.json`. - Output unquoted raw strings (ideal for shell variables): `jq -r '.users[0].name' api.json`.

Quête 112Verrouillé

When troubleshooting DDoS attacks, brute force login attempts, or high-traffic API endpoints, sysadmins rely on one classic pipeline composed of `sort`, `uniq -c`, and `sort -nr`. 1. `sort access.log`: Groups identical lines together (a mandatory prerequisite for `uniq`). 2. `uniq -c`: Counts the number of duplicate occurrences for each unique line, prefixing each line with its tally count. 3. `sort -nr`: Sorts the tally lines **numerically** (`-n`) and in **reverse** (`-r`) order so the most frequent occurrences appear at the top. 4. `head -n 5`: Isolates the top 5 most frequent entries.

Quête 113Verrouillé

Binary executables and database files cannot be read with `cat` or text editors without corrupting the terminal display. Linux provides dedicated tools for inspecting compiled binaries and memory dumps: - `strings <file>`: Scans binary files and extracts continuous human-readable ASCII/UTF-8 character sequences (defaulting to 4+ characters). Essential for finding hardcoded URLs, secret keys, version strings, or embedded error messages in compiled software. - `xxd <file>` or `hexdump -C <file>`: Creates a canonical two-column hexadecimal and ASCII dump of binary files to inspect magic bytes (like `ELF` headers) and binary data offsets.

👑 Boss · Quête 114Verrouillé

ETL DATA INCIDENT: A legacy mainframe exported `/home/learner/messy_data.csv` using unconventional formatting: fields are separated by colons and rows end with semicolons (`alice:dev:engineering;`). The analytics ingestion engine rejects this format. Transform the file into clean CSV format at `/home/learner/clean_users.csv`, containing only the user and department (fields 1 and 3) separated by commas (`alice,engineering`), with semicolons stripped.

14. Environnement et Configuration Shell

Quête 115Verrouillé

Imaginez que vous déployez une application Web et qu'elle doit savoir si elle doit s'exécuter dans un bac à sable de « développement » local sécurisé ou se connecter à la base de données de « production » en direct. Sous Linux, nous transmettons des configurations comme celle-ci aux programmes en cours d'exécution à l'aide de **variables d'environnement**. - Nous utilisons la commande `export` pour définir une variable afin que tous les programmes démarrés par notre shell puissent la lire. Par exemple, `export APP_ENV=production`. - Pour vérifier ou afficher la valeur d'une variable, on préfixe son nom d'un signe dollar : `echo $APP_ENV`.

Quête 116Verrouillé

Imaginez que vous essayez de déboguer un script qui échoue constamment parce qu'il ne trouve pas le chemin d'un programme, ou que vous souhaitez voir quel compte utilisateur est actif dans ce terminal. Sous Linux, toutes ces configurations à l'échelle de la session sont stockées ensemble. - La commande `env` imprime un répertoire complet de toutes les variables d'environnement actuellement chargées dans votre session active, vous permettant de vérifier les configurations en une seule fois.

Quête 117Verrouillé

Maintenant que vous êtes familier avec les variables d'environnement actives comme `PATH` (qui stocke les répertoires dans lesquels Linux recherche les commandes), comment trouver le chemin exact du fichier du programme qui s'exécute lorsque vous tapez `ls` ou `grep` ? Nous utilisons `which` pour localiser les binaires de commandes. - La commande `which` recherche les dossiers répertoriés dans votre variable `$PATH` et imprime le chemin absolu du binaire exécuté lorsque la commande est exécutée (par exemple, `which ls` génère `/bin/ls`). - Ceci est utile pour trouver où un outil est installé ou résoudre des conflits entre plusieurs versions du même outil.

Quête 118Verrouillé

Taper de longues commandes avec plusieurs indicateurs peut devenir épuisant. Sous Linux, nous pouvons créer des raccourcis personnalisés appelés alias. Par exemple, vous pouvez mapper `ll` pour exécuter automatiquement `ls -la`. - Pour créer un alias temporaire, exécutez `alias name='command'` (par exemple `alias ll='ls -la'`). - L'exécution de `alias` sans arguments répertorie tous les alias actifs dans la session en cours. - Pour rendre les alias permanents lors des redémarrages, ils sont généralement écrits dans les fichiers de configuration `.bashrc` ou `.bash_profile`.

Quête 119Verrouillé

When you edit your startup scripts like `~/.bashrc` to add new environment variables or aliases, those changes do not automatically affect your current shell session. Traditionally, users had to log out and log back in. In Linux, we use the `source` command (or its POSIX shorthand `.`) to read and execute commands from a file directly in the current shell context. - Syntax: `source ~/.bashrc` or `. ~/.bashrc` - This loads newly defined variables, updated `$PATH` directories, and aliases immediately without killing your session.

Quête 120Verrouillé

During debugging or deployment, you may temporarily export sensitive API keys, database credentials, or create test shortcuts. Leaving these variables active in your environment can cause security leaks or unintended script behavior. Linux provides `unset` to delete variables and `unalias` to delete custom command shortcuts. - `unset SECRET_KEY`: Permanently deletes the `SECRET_KEY` variable from the current environment. - `unalias la`: Removes the shortcut `la` so typing `la` no longer executes `ls -a`.

👑 Boss · Quête 121Verrouillé

SECURITY BREACH: A malicious session injected a backdoor path `/tmp/evil_bin` into `/home/learner/.bashrc`, attempting to hijack user commands. Eradicate the persistence mechanism: clean `/home/learner/.bashrc` by removing all references to `evil_bin`, and delete the `/tmp/evil_bin` directory entirely from the system.

15. Archivage, Sauvegardes et Checksums

Quête 122Verrouillé

Imaginez que vous disposez d'un dossier contenant 500 journaux de serveur et que vous souhaitez l'envoyer par courrier électronique à un collègue ou le sauvegarder sur un stockage cloud. L'envoi de 500 fichiers individuels est lent et inefficace. Sous Linux, nous les compressons dans un seul fichier compact de type zip en utilisant `tar` (abréviation de « archive sur bande »). - Nous créons des archives compressées à l'aide des indicateurs : `-c` (créer), `-z` (compresser avec gzip), `-v` (liste détaillée des fichiers) et `-f` (spécifier le nom du fichier). Par exemple, `tar -czvf backup.tar.gz folder/` regroupe et compresse le répertoire. **Pourquoi est-ce important** : Si vous exécutez `tar -cz logs.tar.gz logs` sans `-f`, vous obtiendrez : `tar: Refusing to write archive contents to terminal`. L'indicateur `-f` est essentiel car il indique à `tar` d'écrire la sortie dans un fichier au lieu d'envoyer les données brutes de l'archive binaire directement à votre terminal. Les indicateurs `-c` et `-z` sont également requis pour créer et compresser l'archive respectivement.

Quête 123Verrouillé

Imaginez que vous ayez un seul fichier texte contenant un ensemble de données volumineux et que vous souhaitiez réduire sa taille pour économiser de l'espace disque ou accélérer le partage. Sous Linux, nous compressons les fichiers individuels en utilisant `gzip` et les restaurons en utilisant `gunzip`. - La commande `gzip <filename>` compresse un fichier en le remplaçant par une version compressée se terminant par `.gz` (par exemple, `backup.txt` devient `backup.txt.gz`). - La commande `gunzip <filename.gz>` décompresse le fichier en restaurant la version originale.

Quête 124Verrouillé

Alors que `tar` et `gzip` sont standards sous Linux, `zip` est le format d'archive le plus courant dans le monde multiplateforme (Windows/macOS). Sous Linux, nous emballons et compressons les fichiers dans des fichiers zip à l'aide de `zip`, et les extrayons à l'aide de `unzip`. - La commande `zip <archive.zip> <files>` crée une archive zip. - La commande `unzip <archive.zip>` extrait les fichiers de l'archive.

Quête 125Verrouillé

Au-delà de `gzip` et `zip`, Linux prend en charge d'autres formats de compression optimisés pour des taux de compression plus élevés au détriment de la vitesse du processeur. Il s'agit de `bzip2` (bz2) et `xz` (xz). - La commande `bzip2 <file>` compresse un fichier et génère `<file>.bz2`. - La commande `xz <file>` utilise la compression LZMA sans perte pour créer `<file>.xz`, ce qui génère des fichiers de taille exceptionnellement petite, ce qui la rend idéale pour les versions du noyau Linux.

Quête 126Verrouillé

Imaginez que vous ayez un fichier de configuration enfoui profondément dans un dossier imbriqué, disons `/var/www/html/configs/app/settings.conf`, mais que vous devez le modifier constamment. Au lieu de taper le long chemin du dossier à chaque fois, vous souhaitez un raccourci rapide sur le bureau. Sous Linux, nous faisons cela en créant des liens. - **Hard Link** : Un clone direct pointant vers les données brutes du fichier. Si vous supprimez le fichier d'origine, le lien fonctionne toujours. - **Lien symbolique (Soft Link)** : Un raccourci basé sur un chemin (tout comme les raccourcis Windows). Si vous supprimez le fichier d'origine, le lien est rompu. Nous les créons en utilisant `ln -s target link_name`. **Pourquoi est-ce important** : Si vous exécutez `ln logs/app.log app_link.log` sans `-s`, vous créerez un lien physique au lieu d'un raccourci symbolique. Si les fichiers résident sur des partitions de disque différentes, vous obtiendrez : `ln: failed to create hard link: Invalid cross-device link`. L'indicateur `-s` crée un lien symbolique flexible (raccourci) qui fonctionne sur différents lecteurs et répertoires.

Quête 127Verrouillé

Imaginez que vous ayez exécuté une recherche qui a renvoyé 100 fichiers temporaires et que vous souhaitez maintenant tous les supprimer. Le résultat de la recherche n'est qu'une liste de noms de texte sur votre écran. Comment transmettre ces noms en tant qu'entrées directes à la commande de suppression ? Sous Linux, nous comblons cette lacune en utilisant `xargs`. - La commande `xargs` (exécuter les arguments) prend des lignes d'entrée standard (comme la liste de fichiers de `find`) et les transmet une par une comme arguments à une autre commande. - Par exemple, `find . -name "*.tmp" | xargs rm` trouve tous les fichiers temporaires et les supprime tous en un seul passage.

Quête 128Verrouillé

DANGLING LINK ALERT: Following a log consolidation migration, the operational link at `/home/learner/links/current_log` became dangling because its original target was moved. Repair the link farm: update the symbolic link `/home/learner/links/current_log` so it points directly to the real system logging destination `/var/log/syslog`.

Quête 129Verrouillé

While `cp` blindly copies entire files every time, `rsync` (remote sync) uses a delta-transfer algorithm to copy only files and bytes that have changed. It is the gold standard for server migrations, incremental directory backups, and continuous mirroring. - `-a` (archive): Preserves timestamps, symlinks, permissions, and operates recursively. - `-v` (verbose): Shows which files are being copied. - `-z` (compress): Compresses file data during transmission. - Notice trailing slashes: `rsync -avz src/ backup/` copies the contents of `src/` inside `backup/`.

Quête 130Verrouillé

When downloading critical software, ISO images, or backup tarballs over the network, files can become corrupted by transmission errors or tampered with by malicious actors. In Linux, cryptographic checksums verify file integrity bit-for-bit. - `sha256sum <file>`: Computes a 256-bit SHA-2 cryptographic hash. - `md5sum <file>`: Computes a 128-bit MD5 digest. - If a single bit in the file changes, the entire hash string changes completely (the avalanche effect).

Quête 131Verrouillé

Sometimes system administrators need to manipulate raw disk blocks rather than regular filesystem files—such as creating empty swapfiles, zeroing out drives, or writing ISO images directly to USB disks. We use `dd` (dataset definition). - `dd if=<source> of=<destination> bs=<block_size> count=<number>` clones raw blocks. - E.g. `dd if=/dev/zero of=disk.img bs=1M count=1` creates a 1MB dummy disk file filled with null bytes. - When automation scripts require scratch files without race conditions or overwriting existing user data, `mktemp` creates uniquely named files under `/tmp`.

👑 Boss · Quête 132Verrouillé

DATA INTEGRITY INCIDENT: The nightly backup pipeline flagged a corrupted archive in `/home/learner/backups/data_backup.tar.gz`. The mission-critical archive failed integrity checks. 1. Run `sha256sum -c checksums.sha256` inside `/home/learner/backups` (or `sha256sum -c /home/learner/backups/checksums.sha256`) to confirm the corrupted file (`FAILED`). 2. Overwrite the corrupted archive by copying the pristine valid backup from the system cache at `/var/backups/data_backup.tar.gz` into `/home/learner/backups/data_backup.tar.gz`. 3. Re-verify the backup using `sha256sum -c checksums.sha256` to confirm integrity (`data_backup.tar.gz: OK`).

16. Accès Distant et Gestion des Utilisateurs

Quête 133Verrouillé

Jusqu'à présent, vous avez travaillé en tant qu'utilisateur `learner`. Mais sur les serveurs du monde réel, les administrateurs système doivent gérer plusieurs comptes. Apprenons comment ajouter de nouveaux utilisateurs et définir leurs mots de passe. - La commande `useradd` crée un tout nouveau compte utilisateur. Étant donné que la création de comptes affecte la sécurité du système, elle doit être exécutée avec les privilèges de superutilisateur (par exemple `sudo useradd deployer`). - La commande `passwd` définit ou modifie le mot de passe d'un utilisateur. Exécutez en tant que `sudo passwd deployer` pour définir le mot de passe de l'utilisateur du déployeur.

Quête 134Verrouillé

Alors que `useradd` est un utilitaire de bas niveau qui enregistre simplement les détails de l'utilisateur dans les fichiers de configuration système, les systèmes Debian/Ubuntu fournissent un script interactif de haut niveau appelé `adduser` qui automatise la création de dossiers personnels, la définition de mots de passe et l'initialisation des environnements shell. À l'inverse, `userdel` supprime proprement les comptes d'utilisateurs. - L'exécution de `sudo adduser tester` vous guide de manière interactive à travers la configuration utilisateur. - L'exécution de `sudo userdel tester` supprime le compte utilisateur.

Quête 135Verrouillé

Lors du dépannage des erreurs d'autorisation, vous devez vérifier le contexte exact de l'identifiant d'utilisateur et de groupe dans lequel vous exécutez. Nous faisons cela en utilisant `id`. - L'exécution de `id` imprime l'ID utilisateur (UID) de l'utilisateur actuel, l'ID de groupe principal (GID) et toutes les listes de groupes supplémentaires. - L'exécution de `id <username>` interroge des informations pour un utilisateur spécifique.

Quête 136Verrouillé

Sous Linux, les utilisateurs sont organisés en **groupes** pour partager facilement les autorisations. Par exemple, tous les développeurs peuvent appartenir à un groupe nommé `developers`. Cela nous permet de partager des fichiers avec toute l’équipe en même temps. - La commande `groupadd` crée un nouveau groupe. Puisqu'il s'agit d'une configuration système, elle nécessite des privilèges de superutilisateur (par exemple `sudo groupadd developers`). - La commande `groups [username]` répertorie tous les groupes auxquels appartient un utilisateur. Exécuté sans arguments, il affiche les groupes pour l'utilisateur actuel.

Quête 137Verrouillé

Lorsque les équipes de projet réorganisent ou mettent hors service des services, les groupes de sécurité correspondants doivent être nettoyés. Sous Linux, nous supprimons les groupes en utilisant `groupdel`. - La commande `groupdel <group_name>` supprime définitivement un groupe des fichiers de configuration du système, nécessitant les privilèges de superutilisateur.

Quête 138Verrouillé

Maintenant que vous avez créé le compte `deployer`, comment vous y connecter localement pour tester son environnement ? Sous Linux, nous utilisons la commande `su` (utilisateur de remplacement) pour changer de compte sans nous déconnecter. - La commande `su <username>` fait basculer le shell du terminal actuel vers la session de cet utilisateur. - Une fois commuté, l'exécution de `whoami` reflétera le nouveau nom d'utilisateur. - Pour revenir à la session initiale de votre compte utilisateur, tapez `exit` ou appuyez sur `Ctrl+D`.

Quête 139Verrouillé

Changer d'utilisateur localement est utile, mais dans le cloud computing, les serveurs vivent dans des centres de données distants. Pour nous y connecter en toute sécurité sur le réseau, nous utilisons `ssh` (Secure Shell). - La commande `ssh` crypte la connexion entre votre machine et un hôte distant pour empêcher les écoutes clandestines. - Syntaxe : `ssh user@hostname` ou `ssh user@ip_address` (par exemple `ssh admin@192.168.1.100`). - La première connexion vous demandera de vérifier l'authenticité de l'hôte distant en affichant une empreinte ECDSA unique. **Remarque :** Puisqu'il s'agit d'un bac à sable basé sur un navigateur, il n'y a pas de véritable serveur distant auquel se connecter. L’exécution de cette commande vous montrera instantanément le modèle de sortie attendu dans le monde réel (vérification de l’hôte, connexion, session), plutôt qu’une véritable session interactive en direct. Dans un vrai terminal, ssh vous déposerait dans un shell distant véritablement séparé jusqu'à ce que vous tapiez `exit`.

Quête 140Verrouillé

Maintenant que vous savez comment vous connecter à un serveur distant via SSH, comment y copier un fichier local (comme une archive de sauvegarde) ? La commande `scp` (copie sécurisée) copie les fichiers en toute sécurité entre les hôtes en utilisant SSH sous le capot. - La syntaxe est `scp source_path user@host:destination_path`. - Par exemple, `scp log.txt admin@192.168.1.100:/tmp/` copie le fichier `log.txt` local dans le dossier `/tmp/` distant. **Remarque :** Tout comme avec ssh, il n'y a pas de véritable serveur distant ici : l'exécution de cette commande confirme que votre fichier local existe et vous montre le résultat de transfert attendu, mais n'envoie réellement de données nulle part.

Quête 141Verrouillé

When onboarding engineers or automation service accounts, you must configure their supplementary group memberships and default login shells. In Linux, `usermod` modifies existing accounts in `/etc/passwd` and `/etc/group`. - `-aG <group>`: Appends the user to supplementary groups without removing them from existing groups. (CRITICAL: omitting `-a` would replace all existing secondary groups!). - `-s <shell>`: Specifies the new login shell (e.g. `/bin/bash` or `/usr/sbin/nologin`).

Quête 142Verrouillé

Password authentication on remote SSH servers is vulnerable to brute-force attacks and credential stuffing. Production infrastructure relies on asymmetric SSH keypair authentication. - `ssh-keygen -t ed25519`: Generates a high-security Ed25519 public/private keypair (`~/.ssh/id_ed25519` and `~/.ssh/id_ed25519.pub`). - `ssh-copy-id deployer@192.168.1.50`: Automatically appends your local public key to the remote user's `~/.ssh/authorized_keys` file, enabling passwordless login.

Quête 143Verrouillé

When investigating unexpected system load or performing security audits on multi-tenant servers, you must know who is logged in and what commands they are executing. - `who`: Prints logged-in usernames, terminal devices (TTY/PTS), and login timestamps. - `w`: Comprehensive snapshot showing system uptime, load averages, logged-in users, and their currently running processes. - `last`: Parses `/var/log/wtmp` to show recent system reboot and user login history.

Quête 144Verrouillé

When working over SSH, closing your laptop lid or losing Wi-Fi sends a hangup signal (SIGHUP) that immediately terminates your long-running builds, database dumps, and tests. A terminal multiplexer like `tmux` runs persistent virtual terminals on the server independent of your SSH connection. - `tmux new -s <name>`: Starts a new persistent session. - `tmux ls`: Lists all running sessions. - `tmux attach -t <name>`: Re-attaches to a running session from any computer at any time.

👑 Boss · Quête 145Verrouillé

FINAL SECURITY AUDIT: An intrusion detection audit revealed that an unauthorized user account `backdoor` was quietly added to `/etc/passwd`, and an unauthorized administrative group `rogue_admins` was added to `/etc/group`. Audit and cleanse the authentication databases: inspect the files with `cat` or `grep`, safely remove the `backdoor` user using `sudo userdel backdoor`, and delete the `rogue_admins` group using `sudo groupdel rogue_admins`. Verify that both unauthorized entries have been completely eradicated.

17. Git et Conteneurs Linux

Quête 146Verrouillé

Modern Linux servers and cloud infrastructure rely on Git for version control, continuous integration, and infrastructure-as-code deployments. Let's master the core introspection commands. - `git status`: Checks working tree and staging area state, revealing modified, untracked, and staged files. - `git diff`: Shows line-by-line differences between modified files and the last commit. - `git log`: Displays commit hashes, author metadata, and change messages.

Quête 147Verrouillé

Docker encapsulates applications inside isolated Linux cgroups and namespaces (containers). As a DevOps engineer or sysadmin, troubleshooting containerized workloads requires inspecting running containers and executing commands within their namespaces. - `docker ps`: Lists running containers, container IDs, images, uptime, and mapped network ports. - `docker logs <container>`: Streams standard output and error logs generated by the containerized service. - `docker exec -it <container> <command>`: Executes an interactive or diagnostic command directly inside the container namespace.

Quête 148Verrouillé

In Git version control, modifications made to working files must be staged before they can be committed into repository history. - `git add <file>`: Stages modified files into the index (e.g., `git add server.js`), preparing them for commit. - `git commit -m "<message>"`: Records a permanent snapshot of staged changes with a descriptive message (e.g., `git commit -m "Fix config"`). - `git branch`: Lists all local repository branches and indicates the currently active branch with an asterisk.

Quête 149Verrouillé

Managing microservices in production requires controlling container lifecycle states when restarting services after configuration changes or stopping unneeded containers. - `docker restart <name>`: Gracefully stops and immediately starts a running container (e.g., `docker restart web-api`). - `docker stop <name>`: Stops an actively running container (e.g., `docker stop web-api`). - `docker start <name>`: Boots up an existing stopped container without creating a new instance (e.g., `docker start web-api`).

👑 Boss · Quête 150Verrouillé

PRODUCTION OUTAGE: The production web service in container `web-api` is failing health checks because `server.js` was modified with the wrong port. 1. Check the failure logs using `docker logs web-api`. 2. Inspect the repository changes using `git status` and `git diff`. 3. Stage the fix by running `git add server.js`. 4. Commit the fix with `git commit -m "Fix port binding for production"`. 5. Restart the containerized service using `docker restart web-api` to apply the hotfix.