# Linux Commandes de base Guide pratique pour découvrir le terminal Linux, manipuler les fichiers, gérer les permissions, les paquets, les services, le réseau et diagnostiquer les problèmes courants. # 1 - Découvrir Linux et le terminal Comprendre le shell, la syntaxe des commandes, l'aide intégrée et l'élévation de privilèges. # 1.1 - Premiers repères dans Linux Linux se pilote avec une interface graphique, mais aussi avec un **terminal**. Dans ce terminal, un programme appelé **shell** interprète les commandes saisies. Bash est très répandu ; Zsh, Fish et Dash sont d'autres shells possibles. ## Identifier sa session ```bash whoami # utilisateur courant hostname # nom de la machine pwd # dossier de travail actuel echo "$SHELL" # shell configuré pour le compte printf '%s\n' "$0" # shell ou processus de la session actuelle ``` Le symbole affiché avant la saisie est l'**invite de commande**. Par convention, `$` représente un utilisateur normal et `#` le compte `root`. Il ne faut pas recopier ces symboles lorsqu'ils apparaissent dans une documentation. ## Comprendre l'arborescence Linux utilise une arborescence unique dont la racine est `/`. | Chemin | Rôle habituel | |---|---| | `/home` | dossiers personnels des utilisateurs | | `/root` | dossier personnel de l'administrateur `root` | | `/etc` | configuration du système et des services | | `/var` | données variables : journaux, caches, files d'attente | | `/tmp` | fichiers temporaires, souvent nettoyés automatiquement | | `/usr` | programmes, bibliothèques et données partagées | | `/dev` | périphériques représentés sous forme de fichiers | | `/proc` et `/sys` | informations virtuelles sur le noyau et le matériel | | `/mnt` et `/media` | points de montage des stockages | Afficher les principaux dossiers : ```bash ls -la / ``` ## Chemins absolus et relatifs - `/etc/hosts` est un **chemin absolu** : il part de `/`. - `Documents/notes.txt` est un **chemin relatif** : il part du dossier actuel. - `.` représente le dossier actuel. - `..` représente le dossier parent. - `~` représente le dossier personnel de l'utilisateur. ```bash cd /etc # chemin absolu cd ../var # chemin relatif cd ~ # retour au dossier personnel ``` Linux distingue généralement les majuscules des minuscules : `Rapport.txt` et `rapport.txt` sont donc deux noms différents. ## Historique et confort de saisie ```bash history # afficher l'historique history | tail -n 20 # afficher les 20 dernières commandes clear # nettoyer l'affichage du terminal ``` - Flèche `↑` : rappeler une ancienne commande. - `Tab` : compléter un chemin ou une commande. - `Ctrl` + `C` : interrompre le programme au premier plan. - `Ctrl` + `L` : nettoyer l'écran sans effacer l'historique. - `Ctrl` + `D` : fermer le shell courant ou signaler la fin de saisie. # 1.2 - Syntaxe d'une commande Une commande Linux suit habituellement cette forme : ```text commande [options] [arguments] ``` Exemple : ```bash ls -l --human-readable /var/log ``` | Élément | Valeur | Rôle | |---|---|---| | commande | `ls` | programme exécuté | | option courte | `-l` | affichage détaillé | | option longue | `--human-readable` | tailles lisibles | | argument | `/var/log` | dossier traité | ## Options courtes et longues Certaines options courtes peuvent être regroupées : ```bash ls -l -a -h ls -lah ``` Toutes les commandes ne suivent pas exactement les mêmes conventions. Il faut consulter `--help` ou la page de manuel avant de supposer qu'une option existe. ## Espaces, guillemets et caractères spéciaux Un espace sépare les arguments. Un chemin contenant des espaces doit être protégé : ```bash cd "Mes documents" cp 'rapport final.txt' sauvegarde/ cd Mes\ documents ``` Les guillemets simples conservent littéralement leur contenu. Les guillemets doubles permettent encore le remplacement des variables : ```bash nom="Alex" echo 'Bonjour $nom' # affiche : Bonjour $nom echo "Bonjour $nom" # affiche : Bonjour Alex ``` ## Motifs génériques Le shell développe certains motifs avant d'exécuter la commande : | Motif | Signification | Exemple | |---|---|---| | `*` | zéro ou plusieurs caractères | `ls *.log` | | `?` | exactement un caractère | `ls image?.jpg` | | `[abc]` | un caractère de la liste | `ls fichier[123].txt` | | `{a,b}` | plusieurs valeurs générées | `mkdir -p projet/{docs,scripts}` | Toujours vérifier un motif avant une suppression : ```bash printf '%s\n' *.tmp # Puis seulement si la liste est correcte : rm -- *.tmp ``` ## Codes de retour Une commande renvoie un code : `0` signifie généralement réussite, une autre valeur signale une erreur ou un résultat particulier. ```bash ls /etc/hosts echo "$?" ``` Enchaînements utiles : ```bash commande1 && commande2 # commande2 seulement si commande1 réussit commande1 || commande2 # commande2 seulement si commande1 échoue commande1 ; commande2 # commande2 dans tous les cas ``` Exemple prudent : ```bash mkdir sauvegarde && cp -a configuration/ sauvegarde/ ``` ## Commandes internes et exécutables ```bash type cd type ls command -v python3 which python3 # courant, mais command -v est plus portable ``` `type` indique si le nom correspond à une commande interne, un alias, une fonction ou un exécutable. # 1.3 - Obtenir de l'aide Linux fournit l'essentiel de sa documentation directement dans le système. Il est préférable de la consulter, car les options peuvent varier selon la distribution et la version installée. ## Aide rapide ```bash ls --help ip --help systemctl --help ``` Pour une commande interne au shell Bash : ```bash help cd help history ``` ## Pages de manuel ```bash man ls man chmod man systemctl ``` Dans `man` : | Touche | Action | |---|---| | `Espace` ou `Page↓` | page suivante | | `b` ou `Page↑` | page précédente | | `/mot` | rechercher vers le bas | | `n` / `N` | occurrence suivante/précédente | | `g` / `G` | début/fin du manuel | | `q` | quitter | Les manuels sont répartis en sections. Les plus courantes sont : | Section | Contenu | |---|---| | 1 | commandes utilisateur | | 2 | appels système | | 5 | formats de fichiers et configurations | | 8 | commandes d'administration | Si un même nom existe dans plusieurs sections : ```bash man 1 passwd # commande passwd man 5 passwd # format du fichier /etc/passwd ``` ## Rechercher une commande ```bash apropos "espace disque" man -k "network interface" whatis rsync ``` La base de données des manuels doit parfois être générée avec `sudo mandb`. ## Documentation Info et fichiers installés ```bash info coreutils info bash ``` Selon la distribution, les exemples et notes complémentaires se trouvent dans : ```bash ls /usr/share/doc ``` Rechercher le paquet auquel appartient une commande : ```bash # Debian et Ubuntu dpkg -S /usr/bin/rsync # Arch Linux pacman -Qo /usr/bin/rsync # Fedora rpm -qf /usr/bin/rsync ``` ## Bonne méthode 1. Identifier précisément la commande avec `type` ou `command -v`. 2. Lire son résumé avec `--help`. 3. Consulter les exemples et avertissements dans `man`. 4. Tester d'abord sur un fichier ou un dossier non critique. 5. Vérifier le code de retour et le résultat obtenu. Pour les commandes sensibles, ne copiez jamais une ligne trouvée en ligne sans comprendre les chemins, les variables et les droits qu'elle utilise. # 1.4 - Utilisateur, root, su et sudo Linux sépare les tâches courantes des opérations d'administration. Un utilisateur normal limite l'impact d'une erreur ; `root` possède presque tous les droits sur le système. ## Identifier l'utilisateur et ses groupes ```bash whoami id groups ``` Afficher les sessions ouvertes : ```bash who w ``` ## Exécuter une commande avec sudo ```bash sudo systemctl restart ssh sudo apt update ``` `sudo` exécute uniquement la commande qui suit avec des privilèges élevés. Le mot de passe demandé est normalement celui de l'utilisateur courant. Tester ses autorisations : ```bash sudo -v # valider ou renouveler l'authentification sudo -l # lister les commandes autorisées sudo -k # oublier immédiatement l'authentification en cache ``` Ouvrir un shell d'administration seulement lorsque cela est nécessaire : ```bash sudo -i exit ``` ## Différence entre su et sudo ```bash su - utilisateur su - ``` - `su - utilisateur` ouvre une session de connexion pour cet utilisateur. - `su -` tente d'ouvrir une session `root` et demande généralement le mot de passe de `root`. - `sudo -i` utilise les règles `sudo` et conserve une trace des commandes lancées. Sur certaines distributions, le compte `root` n'a volontairement pas de mot de passe utilisable ; l'administration passe alors par `sudo`. ## Redirections et privilèges Cette commande peut échouer, car la redirection `>` est réalisée par le shell normal avant `sudo` : ```bash sudo echo "127.0.0.1 exemple.local" > /etc/hosts ``` Utiliser `tee` : ```bash echo "127.0.0.1 exemple.local" | sudo tee -a /etc/hosts ``` Pour modifier un fichier système de manière contrôlée : ```bash sudoedit /etc/hosts ``` `sudoedit` copie temporairement le fichier, ouvre l'éditeur avec l'identité normale, puis remet le résultat en place avec les droits requis. ## Règles de prudence - Rester utilisateur normal pour les tâches habituelles. - Vérifier les chemins avant toute commande précédée de `sudo`. - Ne jamais lancer un script inconnu avec `curl ... | sudo sh`. - Ne pas modifier `/etc/sudoers` directement ; utiliser `sudo visudo`. - Quitter un shell `root` dès la tâche terminée. - Préférer une commande précise à une session administrateur prolongée. # 2 - Naviguer et gérer les fichiers Se déplacer dans l'arborescence et manipuler fichiers, dossiers et liens sans risque. # 2.1 - Se repérer avec pwd, ls et cd Le shell exécute les commandes dans un **dossier de travail courant**. Bien savoir où l'on se trouve évite de modifier le mauvais fichier. ## Afficher le dossier courant ```bash pwd pwd -P # résoudre les liens symboliques dans le chemin ``` ## Lister le contenu ```bash ls ls -l # détails : droits, propriétaire, taille et date ls -a # inclure les noms commençant par un point ls -lah # détails, fichiers cachés et tailles lisibles ls -lt # trier par date de modification ls -ltr # plus ancien en premier ls -ld /etc # afficher le dossier lui-même, pas son contenu ``` Dans une sortie `ls -l`, le premier caractère indique le type : `d` pour un dossier, `-` pour un fichier ordinaire et `l` pour un lien symbolique. ## Changer de dossier ```bash cd /var/log # chemin absolu cd ../lib # dossier parent, puis lib cd ~ # dossier personnel cd # identique à cd ~ cd - # revenir au dossier précédent ``` Les raccourcis essentiels : | Chemin | Signification | |---|---| | `.` | dossier courant | | `..` | dossier parent | | `~` | dossier personnel | | `-` avec `cd` | dossier visité précédemment | ## Afficher une arborescence Si la commande `tree` est installée : ```bash tree tree -L 2 tree -a -L 2 /etc ``` Sans `tree` : ```bash find . -maxdepth 2 -print ``` ## Noms cachés et complétion Sous Linux, un nom commençant par `.` est caché par convention : `.bashrc`, `.config`, `.ssh`, etc. Il n'est pas secret et reste visible avec `ls -a`. Utilisez `Tab` pour compléter les chemins. Deux pressions peuvent afficher les possibilités. Cette méthode réduit fortement les erreurs de frappe. ## Exemple de navigation contrôlée ```bash cd /var/log pwd ls -lah cd - ``` Avant une commande sensible, associer `pwd` et `ls` constitue un bon réflexe : ```bash pwd ls -la -- . ``` Le séparateur `--` indique la fin des options. Il protège notamment contre un fichier dont le nom commence par `-`. # 2.2 - Créer, copier, déplacer et renommer ## Créer des dossiers et des fichiers ```bash mkdir projet mkdir -p projet/{docs,scripts,sauvegardes} touch notes.txt touch "compte rendu.txt" ``` `mkdir -p` crée aussi les dossiers parents manquants et ne signale pas d'erreur si le dossier existe déjà. `touch` crée un fichier vide ou actualise sa date de modification. ## Copier ```bash cp source.txt copie.txt cp source.txt sauvegardes/ cp -i source.txt copie.txt # demander avant d'écraser cp -a dossier/ sauvegarde/ # copie récursive en préservant les attributs cp -av dossier/ sauvegarde/ # mode détaillé ``` Attention à la barre finale : ```bash cp -a dossier sauvegarde/ # crée sauvegarde/dossier si sauvegarde existe cp -a dossier/. sauvegarde/ # copie le contenu de dossier dans sauvegarde ``` ## Déplacer ou renommer La même commande réalise les deux opérations : ```bash mv ancien.txt nouveau.txt mv rapport.pdf Documents/ mv -i fichier.txt destination/ mv -n fichier.txt destination/ # ne jamais écraser ``` ## Créer rapidement du contenu ```bash printf '%s\n' "Première ligne" "Deuxième ligne" > notes.txt echo "Ligne ajoutée" >> notes.txt ``` `>` remplace le contenu existant. `>>` ajoute à la fin. ## Comparer avant de remplacer ```bash cmp fichier1.bin fichier2.bin diff -u ancienne.conf nouvelle.conf ``` Pour synchroniser des dossiers, `rsync` offre un mode de simulation très utile : ```bash rsync -avhn source/ destination/ # simulation rsync -avh source/ destination/ # exécution ``` ## Gérer les noms particuliers Protéger les espaces : ```bash cp -- "rapport final.txt" "rapport final - copie.txt" ``` Traiter un nom commençant par un tiret : ```bash mv -- -ancien-fichier nouveau-fichier ``` ## Vérifications recommandées ```bash file sauvegarde.tar.gz # identifier le type réel stat fichier.txt # métadonnées détaillées ls -lah destination/ ``` Pour une donnée importante, une copie locale n'est pas forcément une sauvegarde. Une vraie sauvegarde doit idéalement être stockée sur un autre support et testée par une restauration. # 2.3 - Supprimer sans se tromper Sous Linux, `rm` ne place généralement pas les éléments dans une corbeille. Une suppression en ligne de commande peut donc être immédiate et difficile à récupérer. ## Supprimer un fichier ou un dossier vide ```bash rm fichier.tmp rm -i fichier.tmp # demander confirmation rmdir dossier-vide ``` Supprimer plusieurs fichiers précis : ```bash rm -- fichier1.tmp fichier2.tmp ``` ## Supprimer un dossier et son contenu ```bash rm -r ancien-dossier/ rm -ri ancien-dossier/ # confirmation interactive ``` L'option `-f` force la suppression et réduit les protections. La combinaison `rm -rf` doit rester exceptionnelle et ne doit être utilisée qu'après vérification exacte de la cible. ## Méthode sûre avec un motif Avant de supprimer tous les fichiers `.tmp`, afficher ce que le shell sélectionne : ```bash printf '%s\n' -- *.tmp ``` Puis supprimer seulement si la liste est correcte : ```bash rm -i -- *.tmp ``` Avec `find`, commencer par `-print` : ```bash find /var/tmp/mon-application -type f -name '*.tmp' -print ``` Après contrôle : ```bash find /var/tmp/mon-application -type f -name '*.tmp' -delete ``` L'ordre des critères de `find` compte : `-delete` ne doit être ajouté qu'à la fin, après un test réussi avec `-print`. ## Préférer une opération récupérable Si l'environnement graphique fournit `gio` : ```bash gio trash fichier.txt gio trash --list ``` Autre méthode : déplacer d'abord l'élément vers un dossier de quarantaine. ```bash mkdir -p ~/A_supprimer mv -i ancien-dossier ~/A_supprimer/ ``` ## Erreurs à éviter - Ne jamais exécuter une suppression récursive sur `/`, `/home`, `~` ou une variable non vérifiée. - Toujours mettre les variables entre guillemets : `rm -- "$fichier"`. - Ne pas supposer qu'une variable est définie. - Vérifier `pwd`, puis la cible avec `ls -ld -- chemin`. - Ne pas précéder `rm` de `sudo` si les droits normaux suffisent. Exemple de contrôle d'une variable : ```bash cible="/var/tmp/mon-application" test -n "$cible" && test "$cible" != "/" && ls -ld -- "$cible" ``` Cette vérification n'autorise pas automatiquement la suppression ; elle sert seulement à examiner la cible. # 2.4 - Types de fichiers et liens Linux représente de nombreuses ressources sous forme de fichiers : documents, dossiers, périphériques, sockets et liens. ## Identifier un type de fichier ```bash file document.pdf file image-sans-extension stat document.pdf ls -l document.pdf ``` Le début de `ls -l` indique le type : | Caractère | Type | |---|---| | `-` | fichier ordinaire | | `d` | dossier | | `l` | lien symbolique | | `b` | périphérique bloc, par exemple un disque | | `c` | périphérique caractère | | `s` | socket | | `p` | tube nommé | ## Lien symbolique Un lien symbolique contient un chemin vers une autre ressource. Il ressemble à un raccourci. ```bash ln -s /srv/app/config.yml ~/config-app.yml ls -l ~/config-app.yml readlink ~/config-app.yml readlink -f ~/config-app.yml ``` Si la cible est déplacée ou supprimée, le lien devient cassé. Rechercher les liens cassés sous le dossier actuel : ```bash find . -xtype l -print ``` ## Lien physique Un lien physique est un second nom vers les mêmes données sur le même système de fichiers. ```bash ln rapport.txt rapport-alias.txt ls -li rapport.txt rapport-alias.txt ``` Les deux noms affichent le même numéro d'inode. Modifier l'un modifie le contenu visible par l'autre. Supprimer un nom ne détruit les données que lorsqu'aucun lien physique ne les référence plus et qu'aucun processus ne les maintient ouvertes. Les liens physiques ne traversent généralement pas les systèmes de fichiers et ne s'appliquent normalement pas aux dossiers. ## Extension et contenu réel Linux ne dépend pas uniquement de l'extension : ```bash file sauvegarde file --mime-type sauvegarde ``` Un fichier nommé `.jpg` peut ne pas être une image. `file` examine sa signature, sans garantir pour autant qu'il est sûr. ## Informations utiles avec stat ```bash stat -c 'Nom=%n Taille=%s octets Droits=%A Propriétaire=%U Groupe=%G' fichier ``` Sur BSD ou macOS, les options de `stat` diffèrent. Les exemples ci-dessus visent les outils GNU courants sous Linux. # 3 - Lire, rechercher et traiter du texte Afficher, filtrer, rechercher et transformer efficacement des fichiers texte. # 3.1 - Lire un fichier avec cat, less, head et tail ## Afficher un petit fichier ```bash cat /etc/os-release cat -n notes.txt # numéroter les lignes ``` `cat` affiche tout le contenu d'un coup. Il convient aux petits fichiers, mais devient peu pratique pour un journal de plusieurs gigaoctets. Assembler plusieurs fichiers : ```bash cat partie1.txt partie2.txt > document-complet.txt ``` ## Parcourir avec less ```bash less /var/log/syslog less +F /var/log/syslog # suivre les ajouts ; Ctrl+C pour revenir à less ``` Touches essentielles : | Touche | Action | |---|---| | `Espace` / `b` | page suivante / précédente | | `g` / `G` | début / fin | | `/erreur` | rechercher vers le bas | | `n` / `N` | occurrence suivante / précédente | | `F` | suivre les nouvelles lignes | | `q` | quitter | `less` ne charge pas nécessairement tout le fichier en mémoire et convient donc mieux aux gros fichiers. ## Début et fin d'un fichier ```bash head fichier.log head -n 20 fichier.log tail fichier.log tail -n 50 fichier.log ``` Suivre un journal en direct : ```bash tail -f application.log tail -F application.log ``` `-F` continue de suivre le nom même si le fichier est recréé lors d'une rotation de journaux. Quitter avec `Ctrl` + `C`. ## Extraire une plage de lignes ```bash sed -n '20,40p' fichier.txt ``` Cette commande affiche les lignes 20 à 40 sans modifier le fichier. ## Afficher les caractères invisibles ```bash cat -A fichier.txt sed -n 'l' fichier.txt ``` Utile pour repérer tabulations, espaces finaux et fins de ligne Windows. ## Encodage et fins de ligne ```bash file -i fichier.txt ``` Convertir un fichier Windows CRLF vers Linux LF si `dos2unix` est installé : ```bash dos2unix script.sh ``` Avant de lancer un script téléchargé, l'afficher et l'examiner : ```bash less script.sh file script.sh ``` Afficher un fichier est normalement non destructif, mais son contenu peut comporter des séquences de terminal indésirables. Pour une source non fiable, `less` est souvent préférable à l'exécution ou au copier-coller aveugle. # 3.2 - Rechercher avec grep, rg, find et locate ## Rechercher du texte avec grep ```bash grep 'erreur' application.log grep -i 'erreur' application.log # ignorer la casse grep -n 'erreur' application.log # afficher les numéros de ligne grep -v '^#' fichier.conf # exclure les commentaires grep -RIn '192.168.25.1' /etc # recherche récursive ``` Afficher du contexte : ```bash grep -n -C 3 'failed' service.log # 3 lignes avant et après grep -n -A 5 'failed' service.log # 5 lignes après grep -n -B 2 'failed' service.log # 2 lignes avant ``` Expressions régulières étendues : ```bash grep -En 'error|failed|denied' application.log grep -E '^[0-9]{4}-[0-9]{2}-[0-9]{2}' application.log ``` ## Rechercher rapidement avec rg `rg` désigne **ripgrep**. Il est très rapide et ignore par défaut certains fichiers cachés ou exclus par `.gitignore`. ```bash rg 'motif' . rg -n -i 'motif' /etc rg --hidden 'motif' . rg -g '*.yml' 'password' . ``` Il n'est pas installé par défaut partout. Utiliser `grep -R` comme solution universelle. ## Rechercher des fichiers avec find ```bash find . -type f -name '*.log' find /var/log -type f -iname '*error*' find . -type d -name 'cache' find . -type f -size +100M -print find . -type f -mtime -7 -print # modifiés depuis moins de 7 jours find . -maxdepth 2 -type f -print ``` Exécuter une commande sur chaque résultat : ```bash find . -type f -name '*.conf' -exec file {} \; ``` Pour les noms contenant des espaces ou retours à la ligne, préférer des séparateurs nuls : ```bash find . -type f -print0 | xargs -0 file ``` ## Recherche indexée avec locate ```bash locate sshd_config sudo updatedb ``` `locate` interroge une base mise à jour périodiquement : il est rapide, mais peut afficher un fichier qui vient d'être supprimé ou manquer un fichier récent. ## Rechercher une commande disponible ```bash command -v ssh type -a python ``` Toujours délimiter précisément une recherche sous `/` : elle peut être lente, rencontrer des permissions refusées et parcourir des systèmes de fichiers distants. # 3.3 - Redirections, tubes et tee Les commandes utilisent trois flux standards : | Numéro | Flux | Rôle | |---:|---|---| | 0 | entrée standard, `stdin` | données reçues par la commande | | 1 | sortie standard, `stdout` | résultat normal | | 2 | erreur standard, `stderr` | avertissements et erreurs | ## Rediriger la sortie ```bash commande > resultat.txt # remplacer le fichier commande >> resultat.txt # ajouter à la fin commande 2> erreurs.txt # erreurs seulement commande > tout.txt 2>&1 # sortie et erreurs dans le même fichier commande &> tout.txt # raccourci Bash ``` `>` vide le fichier avant d'exécuter la commande. Vérifier le chemin et préférer `>>` lorsqu'un historique doit être conservé. Ignorer une sortie : ```bash commande > /dev/null commande > /dev/null 2>&1 ``` ## Fournir une entrée ```bash sort < noms.txt ``` Document intégré : ```bash cat <<'EOF' Le contenu $VARIABLE reste littéral Deuxième ligne EOF ``` ## Relier des commandes avec un tube Le tube `|` transmet la sortie standard d'une commande à l'entrée de la suivante. ```bash ps aux | grep '[s]shd' journalctl -b | grep -i 'error' find . -type f | wc -l ``` Une chaîne se lit de gauche à droite : produire, filtrer, transformer puis résumer. ```bash cut -d: -f1 /etc/passwd | sort | uniq ``` ## Voir et enregistrer avec tee ```bash ip addr | tee diagnostic-reseau.txt ip addr | tee -a diagnostic-complet.txt ``` Écrire dans un fichier protégé : ```bash printf '%s\n' 'option=valeur' | sudo tee /etc/application.conf ``` `tee` affiche aussi ce qu'il écrit. Ajouter `> /dev/null` pour masquer cette copie d'écran. ## Codes d'erreur dans un pipeline Par défaut, le shell retourne souvent le code de la dernière commande du pipeline. Dans un script Bash sensible : ```bash set -o pipefail commande1 | commande2 echo "$?" ``` `pipefail` signale l'échec d'une commande intermédiaire. Dans un terminal, voir les codes de tout le dernier pipeline : ```bash printf '%s\n' "${PIPESTATUS[@]}" ``` Ne mélangez pas au hasard `sudo`, les redirections et les tubes : chaque partie peut s'exécuter avec des privilèges différents. # 3.4 - Trier et transformer avec sort, uniq, cut, sed et awk Les petits outils Unix sont conçus pour être combinés. Ils permettent d'extraire une information sans ouvrir un tableur ou écrire un programme complet. ## Compter avec wc ```bash wc fichier.txt wc -l fichier.txt # lignes wc -w fichier.txt # mots wc -c fichier.txt # octets ``` ## Trier et supprimer les doublons ```bash sort noms.txt sort -n nombres.txt sort -h tailles.txt sort -r noms.txt sort noms.txt | uniq sort noms.txt | uniq -c | sort -nr ``` `uniq` ne regroupe que les lignes identiques adjacentes ; il est donc souvent précédé de `sort`. ## Extraire des colonnes ```bash cut -d: -f1 /etc/passwd cut -d';' -f1,3 inventaire.csv ``` `cut` convient aux séparateurs simples. Un CSV avec des guillemets, des retours à la ligne ou des séparateurs échappés nécessite un véritable analyseur CSV. ## Remplacer des caractères avec tr ```bash printf '%s\n' 'bonjour' | tr '[:lower:]' '[:upper:]' tr -d '\r' < windows.txt > linux.txt tr ':' '\n' < /etc/passwd ``` ## Transformer avec sed Afficher sans modifier : ```bash sed -n '1,10p' fichier.txt sed 's/ancien/nouveau/g' fichier.txt sed '/^#/d; /^$/d' fichier.conf ``` Créer un nouveau fichier : ```bash sed 's/ancien/nouveau/g' fichier.txt > fichier-modifie.txt ``` La modification directe `sed -i` varie entre GNU/Linux et BSD/macOS. Créer d'abord une sauvegarde : ```bash sed -i.bak 's/ancien/nouveau/g' fichier.txt ``` ## Extraire avec awk ```bash awk -F: '{print $1}' /etc/passwd awk '{print NR, $0}' fichier.txt awk '$3 > 80 {print $1, $3}' mesures.txt df -P | awk 'NR>1 {print $6, $5}' ``` Dans `awk`, `$1` désigne le premier champ, `$0` toute la ligne et `NR` le numéro de ligne. ## Exemple combiné Compter les shells déclarés dans `/etc/passwd` : ```bash cut -d: -f7 /etc/passwd | sort | uniq -c | sort -nr ``` Tester d'abord les transformations sans `-i`, comparer le résultat avec `diff`, puis remplacer le fichier uniquement après validation. # 4 - Permissions, propriétaires et comptes Lire et modifier les permissions, les propriétaires, les utilisateurs et les groupes. # 4.1 - Comprendre les permissions Linux Chaque fichier possède un propriétaire, un groupe et des permissions pour trois catégories : **utilisateur** (`u`), **groupe** (`g`) et **autres** (`o`). ## Lire les droits ```bash ls -l fichier.txt ls -ld dossier stat fichier.txt ``` Exemple : ```text -rw-r----- 1 alex informatique 1250 août 7 10:00 rapport.txt ``` Décomposition : | Bloc | Signification | |---|---| | `-` | fichier ordinaire | | `rw-` | propriétaire : lecture et écriture | | `r--` | groupe : lecture | | `---` | autres : aucun droit | ## Signification sur un fichier | Droit | Lettre | Effet | |---|---|---| | lecture | `r` | lire le contenu | | écriture | `w` | modifier le contenu | | exécution | `x` | lancer le fichier comme programme | ## Signification sur un dossier | Droit | Effet | |---|---| | `r` | lister les noms présents | | `w` | créer, renommer ou supprimer des entrées | | `x` | traverser le dossier et accéder aux éléments connus | Les permissions d'un dossier expliquent pourquoi un utilisateur peut parfois supprimer un fichier qu'il ne peut pas modifier : la suppression agit sur l'entrée du dossier parent. ## Tester un accès ```bash test -r fichier && echo "lisible" test -w fichier && echo "modifiable" test -x script.sh && echo "exécutable" ``` ## Permissions par défaut et umask ```bash umask umask -S ``` La valeur `umask` retire des droits lors de la création. Une valeur courante `022` produit généralement des fichiers `644` et des dossiers `755`. Une valeur `027` limite davantage l'accès des autres utilisateurs. Modification temporaire dans le shell courant : ```bash umask 027 ``` ## Au-delà des droits classiques Un `+` après les permissions dans `ls -l` peut signaler des ACL : ```bash getfacl fichier.txt ``` Les systèmes avec SELinux ou AppArmor peuvent aussi refuser une opération malgré des droits Unix apparemment corrects. Avant d'appliquer `chmod 777`, identifier le propriétaire, les droits du dossier parent, les ACL et le contexte de sécurité. `777` donne lecture, écriture et exécution à tout le monde. Ce n'est presque jamais une bonne correction : cela masque la cause et augmente les risques. # 4.2 - Modifier les droits avec chmod `chmod` modifie les permissions d'un fichier ou d'un dossier. Il accepte une notation symbolique, plus lisible, ou une notation numérique. ## Notation symbolique Catégories : `u` propriétaire, `g` groupe, `o` autres, `a` tous. Opérations : `+` ajouter, `-` retirer, `=` définir exactement. ```bash chmod u+x script.sh # ajouter l'exécution au propriétaire chmod g+w partage/ # autoriser l'écriture au groupe chmod o-r fichier.txt # retirer la lecture aux autres chmod u=rw,g=r,o= fichier # définir précisément les droits chmod a+r documentation.pdf # lecture pour tous ``` ## Notation numérique Chaque droit possède une valeur : lecture `4`, écriture `2`, exécution `1`. | Valeur | Droits | Signification | |---:|---|---| | 7 | `rwx` | lecture, écriture, exécution | | 6 | `rw-` | lecture et écriture | | 5 | `r-x` | lecture et exécution | | 4 | `r--` | lecture seule | | 0 | `---` | aucun droit | ```bash chmod 644 fichier.txt # rw-r--r-- chmod 600 secret.txt # rw------- chmod 755 script.sh # rwxr-xr-x chmod 750 dossier-prive # rwxr-x--- ``` ## Appliquer récursivement ```bash chmod -R u+rwX,g+rX,o-rwx projet/ ``` Le `X` majuscule ajoute l'exécution uniquement aux dossiers et aux fichiers déjà exécutables. Il évite de rendre exécutables tous les documents ordinaires. Pour régler séparément fichiers et dossiers : ```bash find projet -type d -exec chmod 750 {} + find projet -type f -exec chmod 640 {} + ``` Commencer par afficher les cibles : ```bash find projet -type f -print ``` ## Cas courant : clé SSH ```bash chmod 700 ~/.ssh chmod 600 ~/.ssh/authorized_keys chmod 600 ~/.ssh/id_ed25519 chmod 644 ~/.ssh/id_ed25519.pub ``` ## Vérifier ```bash stat -c '%A %a %U:%G %n' fichier.txt namei -l /chemin/vers/fichier.txt ``` `namei -l` affiche les droits de chaque composant du chemin, ce qui aide à repérer un dossier parent non traversable. Ne pas utiliser `chmod -R 777` comme dépannage universel. Accorder seulement les droits nécessaires au bon utilisateur ou au bon groupe. # 4.3 - Propriétaires, groupes, chown et chgrp `chown` change le propriétaire et éventuellement le groupe. `chgrp` change seulement le groupe. ## Examiner l'appartenance ```bash ls -l fichier.txt stat -c '%U:%G %n' fichier.txt id alex getent group informatique ``` ## Changer propriétaire ou groupe ```bash sudo chown alex fichier.txt sudo chown alex:informatique fichier.txt sudo chown :informatique fichier.txt sudo chgrp informatique fichier.txt ``` Appliquer récursivement : ```bash sudo chown -R alex:informatique /srv/projet ``` Une opération récursive doit cibler un chemin explicite et vérifié : ```bash sudo ls -ld /srv/projet sudo find /srv/projet -maxdepth 2 -printf '%u:%g %p\n' ``` ## Dossier partagé par un groupe Créer un dossier collaboratif : ```bash sudo mkdir -p /srv/partage sudo chown root:informatique /srv/partage sudo chmod 2770 /srv/partage ``` Le chiffre spécial `2` active le bit **setgid** sur le dossier. Les nouveaux éléments héritent alors du groupe `informatique` au lieu d'utiliser systématiquement le groupe principal du créateur. Vérifier : ```bash ls -ld /srv/partage ``` La permission de groupe apparaît avec `s`, par exemple `drwxrws---`. ## Bits spéciaux | Bit | Valeur | Usage courant | |---|---:|---| | setuid | 4 | exécuter un programme avec l'identité de son propriétaire | | setgid | 2 | héritage du groupe sur un dossier | | sticky bit | 1 | chacun ne supprime que ses propres fichiers dans un dossier partagé | Exemple du sticky bit : ```bash sudo chmod 1777 /srv/depot-temporaire ``` Le répertoire `/tmp` utilise habituellement ce principe. ## Retrouver les identifiants numériques ```bash id -u alex id -g alex getent passwd alex getent group informatique ``` Sur un partage NFS ou dans un conteneur, les numéros UID/GID sont souvent plus importants que les noms affichés. Une différence d'identifiants peut provoquer un accès refusé malgré des noms semblables. # 4.4 - Gérer les utilisateurs et les groupes La gestion des comptes varie légèrement selon la distribution. Les commandes ci-dessous couvrent les systèmes Linux courants. ## Consulter les comptes ```bash id alex getent passwd alex getent group informatique cut -d: -f1 /etc/passwd ``` `getent` est préférable à la lecture directe des fichiers lorsque les comptes peuvent provenir de LDAP, Active Directory ou d'un autre annuaire. ## Créer un utilisateur Sur Debian et Ubuntu, `adduser` guide la création : ```bash sudo adduser alex ``` Commande plus générique : ```bash sudo useradd -m -s /bin/bash alex sudo passwd alex ``` ## Gérer les groupes ```bash sudo groupadd informatique sudo usermod -aG informatique alex id alex ``` L'option `-aG` signifie **ajouter aux groupes supplémentaires**. Oublier `-a` avec `usermod -G` peut retirer l'utilisateur de ses autres groupes secondaires. La nouvelle appartenance s'applique à la prochaine ouverture de session. Pour un test ponctuel : ```bash newgrp informatique ``` ## Verrouiller ou déverrouiller un compte ```bash sudo passwd -l alex sudo passwd -u alex sudo chage -l alex ``` Verrouiller le mot de passe ne termine pas forcément les sessions existantes et n'interdit pas toujours les autres méthodes d'authentification, comme une clé SSH. La procédure de départ d'un utilisateur doit donc inclure sessions, clés, jetons et tâches planifiées. ## Modifier un shell ```bash chsh -s /bin/bash getent passwd "$USER" cat /etc/shells ``` ## Supprimer un compte Examiner d'abord les fichiers appartenant au compte : ```bash sudo find /home /srv -xdev -user alex -print ``` Puis, selon la distribution : ```bash sudo userdel alex # conserver le dossier personnel sudo userdel -r alex # supprimer aussi le dossier personnel ``` `userdel -r` est destructif. Sauvegarder ou transférer les données avant de l'utiliser. ## Fichiers importants | Fichier | Rôle | |---|---| | `/etc/passwd` | comptes et shells, sans mots de passe en clair | | `/etc/shadow` | empreintes des mots de passe et expiration | | `/etc/group` | groupes locaux | | `/etc/sudoers` | règles sudo, à modifier avec `visudo` | Ne jamais éditer `/etc/shadow` manuellement. Utiliser les commandes prévues afin de préserver la cohérence et les permissions. # 5 - Logiciels, processus, services et journaux Installer des paquets, surveiller les processus, piloter systemd et consulter les journaux. # 5.1 - Installer des logiciels avec apt, pacman et dnf Les gestionnaires de paquets installent les logiciels, leurs dépendances et les mises à jour depuis des dépôts configurés. Utiliser celui de sa distribution évite les installations dispersées. ## Identifier la distribution ```bash cat /etc/os-release ``` ## Debian et Ubuntu : apt ```bash sudo apt update # actualiser l'index apt list --upgradable # voir les mises à jour sudo apt upgrade # appliquer les mises à jour apt search nom apt show paquet sudo apt install paquet sudo apt remove paquet sudo apt purge paquet # retirer aussi sa configuration système sudo apt autoremove # dépendances devenues inutiles ``` Retrouver le paquet d'un fichier installé : ```bash dpkg -S /usr/bin/curl dpkg -L curl ``` ## Arch Linux : pacman ```bash sudo pacman -Syu # synchroniser et mettre tout à jour pacman -Ss nom # rechercher dans les dépôts pacman -Si paquet # informations dépôt pacman -Qi paquet # informations paquet installé sudo pacman -S paquet # installer sudo pacman -Rns paquet # retirer avec dépendances inutiles et configuration pacman -Ql paquet # lister les fichiers pacman -Qo /usr/bin/curl # propriétaire d'un fichier ``` Sur Arch, éviter les mises à jour partielles comme `pacman -Sy paquet` sans mise à niveau générale : elles peuvent rendre les bibliothèques incohérentes. Pour les paquets AUR avec `yay`, examiner le `PKGBUILD` avant la compilation : ```bash yay -S nom-du-paquet ``` ## Fedora : dnf ```bash sudo dnf check-upgrade sudo dnf upgrade dnf search nom dnf info paquet sudo dnf install paquet sudo dnf remove paquet dnf provides /usr/bin/curl ``` ## Vérifier une installation ```bash command -v curl curl --version ``` ## Bonnes pratiques - Lire la liste des paquets supprimés ou remplacés avant de confirmer. - Ne pas mélanger sans nécessité dépôts stables, testing et dépôts tiers. - Préférer les dépôts officiels ou une source vérifiée. - Sauvegarder les configurations importantes avant une mise à niveau majeure. - Ne pas interrompre une opération de paquet en cours. - Sur un serveur, prévoir une fenêtre de maintenance et vérifier les services après la mise à jour. Flatpak, Snap, AppImage et les conteneurs complètent le gestionnaire natif, mais possèdent leurs propres règles de mise à jour, d'isolation et de stockage. # 5.2 - Surveiller et arrêter les processus Un **processus** est une instance d'un programme en cours d'exécution. Il possède un identifiant unique, le PID, ainsi qu'un propriétaire et un état. ## Lister les processus ```bash ps ps aux ps -ef ps -u "$USER" ps -p 1234 -o pid,ppid,user,%cpu,%mem,etime,cmd ``` Rechercher par nom : ```bash pgrep -a sshd pidof sshd ``` Éviter `ps aux | grep nom` lorsque `pgrep -a nom` suffit. ## Surveiller en direct ```bash top htop ``` Dans `top`, `P` trie par processeur, `M` par mémoire et `q` quitte. `htop` est plus convivial mais n'est pas toujours installé. Résumé de la mémoire : ```bash free -h ``` Sous Linux, une partie de la mémoire « utilisée » sert de cache récupérable. La colonne `available` est généralement plus pertinente que `free` seule. ## Envoyer un signal ```bash kill 1234 # SIGTERM : demande un arrêt propre kill -15 1234 # identique kill -9 1234 # SIGKILL : arrêt forcé par le noyau pkill -TERM nom ``` Méthode recommandée : 1. vérifier le PID et le propriétaire ; 2. envoyer `SIGTERM` ; 3. attendre et contrôler ; 4. utiliser `SIGKILL` seulement si le processus ne répond pas. `SIGKILL` empêche le programme de nettoyer ses fichiers temporaires ou de terminer une écriture. ## Tâches au premier et à l'arrière-plan ```bash commande-longue & jobs fg %1 bg %1 ``` Suspendre le programme au premier plan avec `Ctrl` + `Z`, puis utiliser `bg` ou `fg`. `Ctrl` + `C` demande son interruption. Garder une commande après la fermeture du terminal : ```bash nohup commande-longue > commande.log 2>&1 & ``` Pour les tâches importantes, préférer un service systemd, `tmux` ou `screen`, qui offrent une gestion plus claire. ## Priorité ```bash nice -n 10 commande renice 10 -p 1234 ``` Une valeur `nice` plus élevée réduit la priorité CPU. Des valeurs négatives demandent généralement des privilèges. Pour un service, agir avec `systemctl` plutôt que tuer directement son processus : le gestionnaire peut sinon le relancer immédiatement. # 5.3 - Gérer les services avec systemctl Sur de nombreuses distributions, **systemd** démarre le système et gère les services. Une unité de service porte généralement un nom comme `ssh.service` ou `nginx.service`. ## Examiner un service ```bash systemctl status ssh systemctl is-active ssh systemctl is-enabled ssh systemctl show ssh ``` Le nom peut être `sshd` au lieu de `ssh` selon la distribution : ```bash systemctl list-unit-files --type=service | grep -i ssh ``` ## Démarrer, arrêter et recharger ```bash sudo systemctl start nginx sudo systemctl stop nginx sudo systemctl restart nginx sudo systemctl reload nginx sudo systemctl reload-or-restart nginx ``` `reload` demande au service de relire sa configuration sans arrêt complet, s'il prend cette opération en charge. Après une modification, valider la syntaxe avant le rechargement : ```bash sudo nginx -t && sudo systemctl reload nginx ``` ## Démarrage automatique ```bash sudo systemctl enable nginx sudo systemctl disable nginx sudo systemctl enable --now nginx sudo systemctl disable --now nginx ``` `enable` prépare le prochain démarrage mais ne lance pas forcément le service immédiatement. `--now` combine les deux actions. ## Masquer un service ```bash sudo systemctl mask nom.service sudo systemctl unmask nom.service ``` `mask` empêche tout démarrage, même manuel ou demandé par une dépendance. À utiliser seulement lorsque cet effet est voulu. ## État général ```bash systemctl --failed systemctl list-units --type=service --state=running systemctl list-timers --all ``` ## Après modification d'une unité ```bash sudo systemctl daemon-reload sudo systemctl restart mon-service ``` `daemon-reload` est requis après modification d'un fichier `.service`, `.timer` ou d'une surcharge systemd ; il n'est pas nécessaire pour la configuration interne de l'application. Créer une surcharge sans modifier le fichier fourni par le paquet : ```bash sudo systemctl edit mon-service ``` Puis vérifier la configuration assemblée : ```bash systemctl cat mon-service systemd-analyze verify /etc/systemd/system/mon-service.service ``` ## Redémarrer ou éteindre ```bash systemctl reboot systemctl poweroff ``` Sur un serveur distant, confirmer qu'aucune opération de stockage ou mise à jour critique n'est en cours avant l'arrêt. # 5.4 - Consulter les journaux avec journalctl et dmesg Les journaux permettent de comprendre ce qui s'est produit avant de modifier la configuration. Avec systemd, `journalctl` interroge le journal central. ## Journaux d'un service ```bash journalctl -u ssh journalctl -u nginx --since today journalctl -u nginx -n 100 journalctl -u nginx -f ``` `-f` suit les nouvelles entrées ; quitter avec `Ctrl` + `C`. ## Journaux du démarrage ```bash journalctl -b # démarrage actuel journalctl -b -1 # démarrage précédent journalctl --list-boots ``` Priorités importantes : ```bash journalctl -p warning..alert -b journalctl -p err -b ``` Filtrer dans le temps : ```bash journalctl --since "2026-08-07 08:00:00" --until "2026-08-07 09:00:00" journalctl --since "30 minutes ago" ``` Afficher sans pagination : ```bash journalctl -u nginx --no-pager -n 50 ``` ## Messages du noyau ```bash dmesg -T sudo dmesg -T | tail -n 100 sudo dmesg -T | grep -Ei 'error|fail|warn' journalctl -k -b ``` Les dates produites par `dmesg -T` peuvent être approximatives après une veille ou une modification de l'horloge ; `journalctl -k` fournit souvent un contexte temporel plus cohérent. ## Journaux classiques Selon la distribution et le service : ```bash ls -lah /var/log sudo less /var/log/auth.log sudo less /var/log/syslog sudo less /var/log/messages ``` ## Espace occupé ```bash journalctl --disk-usage sudo journalctl --vacuum-time=14d ``` La dernière commande supprime les journaux archivés plus anciens que 14 jours. Elle doit respecter la politique de conservation et les besoins d'audit. ## Collecte de diagnostic ```bash journalctl -u mon-service --since "1 hour ago" --no-pager > journal-service.txt systemctl status mon-service --no-pager >> journal-service.txt ``` Avant de partager un journal, rechercher et masquer mots de passe, jetons, adresses privées sensibles, noms d'utilisateurs et autres secrets. # 6 - Réseau, Web et accès distant Contrôler la configuration réseau, tester DNS et ports, télécharger et administrer à distance. # 6.1 - Adresses IP et tests de connectivité Le diagnostic réseau doit progresser du local vers le distant : interface, adresse, route, passerelle, DNS, port puis application. ## Afficher les interfaces et les adresses ```bash ip -brief link ip -brief address ip address show ip link show enp1s0 ``` Activer ou désactiver une interface temporairement : ```bash sudo ip link set enp1s0 up sudo ip link set enp1s0 down ``` Sur une machine distante, désactiver l'interface utilisée par SSH coupe immédiatement la connexion. ## Afficher les routes ```bash ip route ip -6 route ip route get 1.1.1.1 ``` `ip route get` indique la route, l'interface et l'adresse source choisies par le noyau. ## Tester la pile locale et une destination ```bash ping -c 4 127.0.0.1 ping -c 4 192.168.1.1 ping -c 4 1.1.1.1 ping -c 4 example.com ``` Interprétation progressive : 1. `127.0.0.1` teste la pile IP locale. 2. La passerelle teste le lien au réseau local. 3. Une IP Internet teste le routage sans dépendre du DNS. 4. Un nom de domaine teste aussi la résolution DNS. Certains équipements bloquent ICMP. Un échec de `ping` ne prouve donc pas à lui seul que le service est indisponible. ## Voir le chemin suivi ```bash tracepath example.com traceroute example.com ``` `tracepath` est souvent utilisable sans privilèges. Les étoiles peuvent correspondre à un routeur qui ne répond pas aux sondes, sans que le trafic final soit nécessairement bloqué. ## NetworkManager Si la machine utilise NetworkManager : ```bash nmcli device status nmcli connection show nmcli device show enp1s0 ``` ## Statistiques et erreurs d'interface ```bash ip -s link show enp1s0 sudo ethtool enp1s0 ``` Rechercher pertes, erreurs, négociation de vitesse et état du lien. `ethtool` peut nécessiter une installation séparée. Les commandes `ip` modifient souvent l'état en mémoire seulement. Pour une configuration persistante, utiliser l'outil de la distribution : NetworkManager, systemd-networkd, Netplan ou les fichiers réseau prévus. # 6.2 - DNS, routes et ports réseau ## Vérifier la résolution DNS ```bash getent hosts example.com resolvectl query example.com dig example.com dig +short example.com dig @1.1.1.1 example.com ``` `getent` suit la configuration complète du système, y compris `/etc/hosts`, DNS et éventuellement un annuaire. `dig` interroge directement le DNS et fournit davantage de détails. Afficher la configuration DNS gérée par systemd-resolved : ```bash resolvectl status ``` Examiner aussi : ```bash cat /etc/resolv.conf grep '^hosts:' /etc/nsswitch.conf ``` Ne pas modifier `/etc/resolv.conf` avant de vérifier s'il est généré automatiquement. ## Afficher la table de routage et les voisins ```bash ip route ip neigh ``` `ip neigh` remplace les usages courants de l'ancienne commande `arp`. ## Voir les ports en écoute ```bash ss -tuln sudo ss -tulpn ss -tan state established ``` Options : `t` TCP, `u` UDP, `l` écoute, `n` valeurs numériques, `p` processus. Exemples ciblés : ```bash sudo ss -ltnp 'sport = :22' sudo lsof -iTCP:8080 -sTCP:LISTEN ``` ## Tester un port distant ```bash nc -vz serveur.example 22 nc -vz 192.168.1.10 443 ``` Pour HTTPS, tester aussi le protocole réel : ```bash curl -I --connect-timeout 5 https://serveur.example openssl s_client -connect serveur.example:443 -servername serveur.example sauvegarde.tar.gz.sha256 sha256sum -c sauvegarde.tar.gz.sha256 ``` Une somme de contrôle détecte une modification accidentelle, mais ne prouve l'authenticité que si la somme attendue vient d'une source fiable. # 7.3 - Informations système et matériel ## Système d'exploitation et noyau ```bash cat /etc/os-release uname -a uname -r hostnamectl uptime ``` `/etc/os-release` décrit la distribution ; `uname -r` indique le noyau actuellement démarré, qui peut différer du dernier noyau installé. ## Processeur et mémoire ```bash lscpu free -h grep -E 'MemTotal|MemAvailable|SwapTotal|SwapFree' /proc/meminfo ``` ## Matériel PCI, USB et disques ```bash lspci lspci -nnk lsusb lsblk -o NAME,MODEL,SERIAL,SIZE,TYPE,FSTYPE,MOUNTPOINTS ``` `lspci -nnk` affiche les identifiants matériels, le pilote utilisé et les modules disponibles, très utile pour un GPU ou une carte réseau. ## Modules du noyau ```bash lsmod modinfo nom_du_module sudo modprobe nom_du_module ``` Retirer un module peut couper un périphérique actif. Ne pas utiliser `modprobe -r` à distance sur le pilote de la carte réseau employée. ## Périphériques et événements récents ```bash sudo dmesg -T | tail -n 100 journalctl -k -b udevadm info --query=all --name=/dev/sdb ``` ## Temps et fuseau horaire ```bash date timedatectl ``` Sur un serveur, une horloge incorrecte peut casser TLS, Kerberos, l'authentification et la corrélation des journaux. ## Charge et sessions ```bash uptime w last -n 20 ``` Les trois valeurs de charge d'`uptime` couvrent environ 1, 5 et 15 minutes. Elles doivent être interprétées avec le nombre de processeurs logiques et l'attente d'entrées-sorties. ## Construire un petit rapport non sensible ```bash { date hostnamectl uptime free -h df -hT ip -brief address } > diagnostic-systeme.txt ``` Examiner le fichier avant de le transmettre : il peut révéler nom de machine, adresses IP, utilisateurs, numéros de série ou structure du stockage. ## Commandes optionnelles utiles ```bash inxi -Fxxxz # synthèse détaillée si inxi est installé sudo dmidecode # informations DMI/BIOS, nécessite root sudo smartctl -a /dev/sda # santé SMART si smartmontools est installé ``` Ne lancez pas de test SMART long ou destructif sur un disque de production sans connaître son impact et sans sauvegarde valide. # 7.4 - Méthode de dépannage et mémo des commandes ## Méthode de dépannage Une bonne résolution d'incident sépare les faits, les hypothèses et les modifications. 1. **Décrire le symptôme** : message exact, heure, utilisateur et action. 2. **Définir le périmètre** : une application, une machine, un VLAN ou tous les utilisateurs. 3. **Reproduire prudemment** : noter les étapes et éviter d'aggraver l'incident. 4. **Observer avant de modifier** : état du service, journaux, ressources, réseau. 5. **Formuler une hypothèse testable** : une cause à la fois. 6. **Changer une seule chose** : noter la commande et prévoir le retour arrière. 7. **Valider de bout en bout** : service, client, persistance après redémarrage si nécessaire. 8. **Documenter** : cause, correction, vérification et prévention. ## Collecte initiale ```bash date hostnamectl uptime systemctl --failed free -h df -hT df -i ip -brief address ip route ``` Pour un service : ```bash systemctl status mon-service --no-pager journalctl -u mon-service --since "30 minutes ago" --no-pager sudo ss -tulpn ``` ## Mémo des commandes essentielles | Besoin | Commande | |---|---| | savoir où je suis | `pwd` | | lister en détail | `ls -lah` | | changer de dossier | `cd chemin` | | copier un dossier | `cp -a source destination` | | déplacer/renommer | `mv -i source destination` | | lire un gros fichier | `less fichier` | | suivre un journal | `tail -F fichier.log` | | rechercher du texte | `grep -RIn 'motif' chemin` | | trouver un fichier | `find chemin -type f -name 'motif'` | | espace disque | `df -hT` et `du -xhd1 chemin` | | mémoire | `free -h` | | processus | `ps aux`, `top`, `pgrep -a nom` | | service | `systemctl status nom` | | journaux | `journalctl -u nom -n 100` | | réseau | `ip -brief address`, `ip route` | | DNS | `getent hosts nom` | | ports | `sudo ss -tulpn` | | accès distant | `ssh utilisateur@serveur` | | aide | `commande --help`, `man commande` | ## Commandes qui exigent une attention particulière - `rm -rf` : suppression récursive sans confirmation. - `chmod -R` et `chown -R` : changement récursif de droits ou propriétaire. - `dd` : copie brute capable d'écraser un disque entier. - `mkfs` : création d'un système de fichiers, donc destruction du contenu précédent. - `fdisk`, `parted`, `zpool destroy` : modification ou destruction du stockage. - `rsync --delete` : suppression dans la destination. - modification de `/etc/fstab`, du réseau ou de SSH : risque de perte d'accès après redémarrage. Avant une commande sensible : ```bash whoami pwd ls -ld -- /chemin/cible ``` Utiliser ensuite un mode simulation lorsqu'il existe, par exemple `rsync -n`, puis relire la commande complète. Une sauvegarde n'est considérée valide qu'après un test de restauration.