Invité.
Utilisateur Niveau 1
Aucune inscription requise. Progression sauvegardée localement. Exportez votre code pour continuer sur un autre appareil.
BADGES OBTENUS
AIDE & MENTIONS
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.
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
Qui suis-je et où suis-je ?
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.
Navigation et liste des fichiers
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).
Structure de répertoire Linux et FHS
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.
Création de répertoires
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.
Répertoires et options imbriqués
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.
Effacer l'écran
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.
Trouver l'aide de Shell
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.
2. Manipulation de Fichiers
Création de fichiers vides
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.
Lire le contenu d'un fichier
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`.
Aperçu des fichiers (tête et queue)
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.
Défilement interactif des fichiers (moins et plus)
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.
Gestion des espaces dans les noms de fichiers
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`).
Écriture et écrasement de fichiers
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.
Ajout aux fichiers
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é.
Copier et déplacer des fichiers
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`).
Caractères génériques et opérations multi-fichiers
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`.
Suppression de fichiers et de dossiers
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.
3. Tubes et Filtrage
Introduction aux tuyaux et toilettes
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.
Trier et trouver des cartes uniques
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.
Filtrage avec grep
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 ».
4. Redirection et Sécurité
Modification des autorisations de fichiers
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 !
Fichiers et configurations cachés
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.
Changement de propriétaire du fichier
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 ».
Pare-feu Linux (ufw et iptables)
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.
5. Superutilisateur et Paquets
Privilèges de superutilisateur (sudo)
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.
Gestion des packages (apt)
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.
Recherche de packages (apt search)
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`).
Purge des packages (apt purge)
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`).
Gestion des paquets Debian (dpkg)
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.
Gestionnaires de packages RedHat (yum & dnf)
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`.
6. Disque et Ressources Système
Vérification de l'espace disque (df)
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.
Recherche de la taille des répertoires (du)
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.
Vérification de l'utilisation de la mémoire (gratuite)
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.
Disponibilité du système et détails du noyau
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.
Affichage des détails du processeur (lscpu)
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.
Statistiques d'E/S et du processeur (iostat)
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.
7. Gestion des Processus
Liste des processus en cours d'exécution (ps)
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.
Moniteur de processus interactif (en haut)
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.
Listage des fichiers ouverts (lsof)
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).
Arrêter les processus malveillants (kill)
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 !
Exécution de tâches en arrière-plan
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.
Gentilité du processus (nice & renice)
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.
Reprise des tâches en arrière-plan (bg)
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.
8. Dépannage Réseau
Test de connectivité (ping)
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.
Interfaces réseau et IP locale
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.
Vérification des interfaces (ifconfig)
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.
Connexions réseau (nmcli)
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.
Statistiques de socket et de connexion (netstat & ss)
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.
Traçage des itinéraires de paquets (traceroute)
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.
Téléchargement de fichiers Web (curl)
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`.
9. Recherche de Fichiers
Recherche de fichiers par nom (rechercher)
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.
Vérification de l'historique des commandes
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).
Consultation des pages du manuel
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.
10. Services et Systemd
Services de contrôle (systemctl)
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>`.
Journalisation du système (journalctl)
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.
11. Édition de Texte dans le Terminal
Modification des fichiers de configuration (nano)
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.
12. Scripts Shell et Automatisation
Écrire votre premier script Bash
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`.
Variables et arguments (1 $)
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.
Logique conditionnelle (if/else)
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.
Automatisation avec des boucles
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.
Logique réutilisable (fonctions bash)
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"`.
Planification des tâches (crontab)
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.
13. Traitement de Texte Avancé
Édition de flux avec sed
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.
Extraction de données avec awk
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.
Traduire et découper des données
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.
14. Environnement et Utilisateurs
Gestion des variables d'environnement
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`.
Archives et compression (tar)
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.
Compression de fichiers (gzip et gunzip)
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.
Archivage avec zip et décompression
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.
Compression alternative (bzip2 & xz)
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.
Inspection de l'environnement
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.
Trouver des commandes (lesquelles)
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.
Raccourcis Shell personnalisés (alias)
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`.
15. Système de Fichiers Avancé
Création de liens (ln -s)
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.
Traitement des résultats de recherche (xargs)
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.
16. Accès Distant et Gestion des Utilisateurs
Administration des utilisateurs (useradd & passwd)
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.
Gestion des utilisateurs (adduser et userdel)
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.
Affichage des identités utilisateur (id)
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.
Administration des groupes (groupadd et groupes)
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.
Suppression de groupes (groupdel)
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.
Changer de contexte de sécurité (su)
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`.
Secure Shell Access (ssh)
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`.
Transfert de fichiers sécurisé (scp)
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.
Who Am I and Where Am I?.
Référence des Commandes
Liste de Vérification
Indices Révélés
File Explorer
Qu'est-ce que BashQuest ?
Plateforme gratuite d'entraînement au terminal Linux et jeu éducatif Bash. Exécutez de vraies commandes sur un système de fichiers virtuel avec validation immédiate.
Qu'est-ce que BashQuest ?
BashQuest est une plateforme gratuite d'entraînement au terminal Linux en ligne et un jeu interactif conçu pour un apprentissage actif. Contrairement aux vidéos passives, vous apprenez en tapant directement les commandes.
BashQuest offre l'expérience d'un véritable terminal en ligne avec des objectifs pédagogiques clairs. Tout s'exécute de façon sûre dans votre navigateur.
Pourquoi ce projet ?
Au début de mon apprentissage de Linux, j'avais peur de casser mon système. J'ai voulu créer un bac à sable zéro risque où chacun peut apprendre Linux gratuitement sans installer de machine virtuelle.
La répétition guidée développe de véritables automatismes : taper les commandes, analyser la sortie et corriger jusqu'au résultat voulu.
Pratique du Terminal Linux en Ligne avec Feedback Instantané
L'apprentissage est plus efficace lorsqu'on met en pratique immédiatement. BashQuest fournit un terminal simulé validant chaque étape en temps réel.
Un Terminal Virtuel pour un Apprentissage Efficace
BashQuest offre l'expérience d'un véritable terminal en ligne avec des objectifs pédagogiques clairs. Tout s'exécute de façon sûre dans votre navigateur.
Pourquoi la Pratique Améliore la Mémorisation
La répétition guidée développe de véritables automatismes : taper les commandes, analyser la sortie et corriger jusqu'au résultat voulu.
Ce que vous allez apprendre
Notre programme progressif couvre 16 domaines clés de l'administration Linux :
Bases du Système de Fichiers
Manipulation de Fichiers
Tubes et Filtrage
Redirection et Sécurité
Superutilisateur et Paquets
Disque et Ressources Système
Gestion des Processus
Dépannage Réseau
Recherche de Fichiers
Services et Systemd
Édition de Texte dans le Terminal
Scripts Shell et Automatisation
Traitement de Texte Avancé
Environnement et Utilisateurs
Système de Fichiers Avancé
Accès Distant et Gestion des Utilisateurs
Outils & Utilitaires Web Linux
Calculateur de permissions chmod, générateur cron, testeur d'expressions régulières et générateur de commandes.
Chmod calculator
Octal & symbolic output
chmod 000 [file]Cron job explainer
Plain-English translation
Command synthesizer
Pick a task, get the command
Select a task above to see the command.
—