Skip to content

Util-Linux

Abstract

Pour voire les différents services leurs états et les logs rendez-vous sur systemd

Audit Rapide : Qui, Quoi, Où ?

Introduction aux commandes universelles pour comprendre le contexte d'exécution de la machine, sa version et son état actuel.

Objectif Commande Détails
Version OS cat /etc/*release Affiche la distribution et sa version (ex: Debian 12, Ubuntu 22.04).
Noyau (Kernel) uname -a Affiche la version du noyau Linux et l'architecture (x86_64, aarch64...).
Qui suis-je ? whoami / id Vérifie avec quel utilisateur vous êtes connecté et vos groupes.
Qui est là ? w Liste les utilisateurs connectés actuellement et leur charge.
Depuis quand ? uptime Temps de fonctionnement et charge système (load average).
Processus ps aux Liste complète de tout ce qui tourne (PID, User, Commande).
Monitoring top / htop Vue dynamique CPU/RAM (pour quitter : q).
Ressources free -h / df -h État de la RAM (free) et des Disques (df).

Note

Astuce : Sur les systèmes modernes (systemd), la commande hostnamectl donne un résumé parfait de l'OS, du noyau et de l'architecture en une seule fois.

Gestion des Commmandes

Exemple

Vous avez lancé :

sudo apt update && sudo apt install fastfetch -y

Puis, sans le vouloir, vous avez interrompu le job avec Ctrl+Z.
Le shell a affiché :

[1]+  Stopped                 sudo apt update && sudo apt install fastfetch -y

Le processus est donc stoppé (recev SIGSTOP) et il n’est plus en cours d’exécution.
Ensuite vous avez tapé :

bg 1

Ce qui a simplement re‑mis le job en arrière‑plan, mais sans interface terminale pour afficher les messages ou demander un mot de passe (si nécessaire).

1. Reprendre un job en cours

Action Commande Résultat
Replacer le job en avant‑plan (et voir les messages) fg %1 ou simplement fg Le processus reprend où il s’était arrêté, vous retrouvez le prompt interactif et vous pouvez saisir votre mot de passe sudo si besoin.
Laisser le job en arrière‑plan (sans interaction) bg %1 (déjà fait) Le job continue, mais tous les messages sont envoyés vers le terminal sans que vous puissiez répondre.
Annuler (tuer) le job kill %1 ou kill -9 %1 Le processus est arrêté définitivement. Vous devrez le relancer.

Exemple

# Reprendre en avant‑plan et entrer le mot de passe sudo
fg %1          # (ou simplement fg si c’est le seul job)
# Vous verrez alors le prompt sudo demander le mot de passe.

Astuce : si votre job ne nécessite aucune interaction (ex. -y pour apt install), il peut rester en arrière‑plan sans problème. Mais le premier apt update demande généralement de confirmer le téléchargement de paquets ou d’attendre la mise à jour de la liste, ce qui ne s’affiche pas correctement en background.

2. Redémarrer la mise à jour proprement

Si vous avez déjà tué le job ou si vous préférez repartir à zéro :

# Option 1 – En avant‑plan (recommandé pour voir les erreurs éventuelles)
sudo apt update && sudo apt install fastfetch -y

# Option 2 – En arrière‑plan, sans interaction (utile pour les scripts automatisés)
nohup sudo apt update && sudo apt install fastfetch -y >~/apt.log 2>&1 &
  • nohup empêche le processus d’être tué si vous fermez le terminal.
  • La sortie est redirigée vers ~/apt.log où vous pouvez vérifier plus tard ce qui s’est passé.

3. Vérifier que tout fonctionne

Après l’installation, vous pouvez vérifier rapidement :

fastfetch

ou, pour vous assurer qu’apt ne tourne plus en arrière‑plan :

ps aux | grep -i apt
# ou
pgrep -fl apt

4. Récapitulatif des commandes utiles

Situation Commande
Lister les jobs en cours jobs
Mettre un job arrêté en background bg %<num>
Faire revenir un job en avant‑plan fg %<num>
Tuer un job kill %<num> (ou kill -9 %<num> en dernier recours)
Lancer une commande en arrière‑plan dès le départ command &
Lancer une commande indépendante du terminal nohup command >logfile 2>&1 &
Voir les processus apt ps -C apt -o pid,cmd
Vérifier l’état du disque lsblk, df -h, sudo fdisk -l

En bref

  • bg redémarre le job en arrière‑plan, mais vous ne voyez plus les messages ni ne pouvez entrer un mot de passe.
  • fg ramène le job au premier plan, vous permettant de répondre à sudo et de suivre la progression.
  • Si le job était déjà arrêté, vous pouvez simplement le tuer (kill %1) puis le relancer proprement.

Identifier un processus (Utilisateur et Origine)

Lorsqu'un processus s'exécute en arrière-plan, il est utile d'identifier qui l'exécute (l'utilisateur) et qui l'a déclenché (le processus parent : un terminal, un service systemd, une tâche cron, etc.).

1. Trouver l'utilisateur et le PID

Pour chercher un processus spécifique et afficher son propriétaire (User), son PID, son parent (PPID) et sa commande complète :

# Filtrer spécifiquement (par exemple sur python3) pour formater l'affichage
ps -o user,pid,ppid,cmd -C python3 | grep "nom_du_processus"

# Ou chercher sur l'ensemble des processus
ps aux | grep "nom_du_processus"

Une méthode plus directe pour obtenir le processus et toute sa ligne de commande (-f) : 

pgrep -af "nom_du_processus"

Une fois que vous avez récupéré le PID, vous pouvez cibler précisément ce processus pour voir à qui il appartient : 

ps -o user,pid,ppid,cmd -p <PID>

2. Déterminer l'origine (L'arborescence)

Pour comprendre d'où vient un processus, regardez son processus parent (PPID). L'outil pstree retrace toute la généalogie depuis la racine du système :

pstree -aps <PID>

Ce résumé visuel permet de vérifier très vite la nature du flux déclencheur. Exemples de parents fréquents : - systemd : S'il s'agit d'un service système (systemctl status <nom_service>). - crond : S'il s'agit d'une tâche planifiée. - sshd / bash : Si le processus a été lancé depuis une session utilisateur.

3. Trouver un processus planifié (cron)

Si votre processus parent est remonté comme crond, l'exécution est gérée par cron. Il faut inspecter les différents endroits où cron lit ses règles.

Les crontabs utilisateurs

Chaque utilisateur du système peut avoir son propre cron, listés et stockés dans /var/spool/cron/crontabs/ (ou /var/spool/cron/).

# Voir les logs cron courants
crontab -l

# Voir les cron d'un autre utilisateur
sudo crontab -l -u <user>

# Lister tous les crons utilisateurs existants
sudo ls /var/spool/cron/crontabs/

Les crontabs système

Les paquets des distributions, logiciels déployés ou les gestionnaires de configuration (comme Puppet ou Ansible) évitent de modifier les crons utilisateurs. Ils déposent ou écrivent plutôt dans les configurations centrales du système :

# Configuration centrale
cat /etc/crontab

# Répertoires dédiés aux crons tiers
ls -la /etc/cron.d/
cat /etc/cron.d/*

Détecter un processus conteneurisé

Il arrive qu'un processus semble tourner sur la machine (visible via ps), mais que ses fichiers soient introuvables. C'est souvent le signe qu'il tourne dans un conteneur (Docker, LXC, etc.).

Méthodologie d'identification (Cas pratique)

Prenons l'exemple d'un processus Tomcat qui semble utiliser /opt/tomcat/, mais ce dossier n'existe pas sur l'hôte.

1. Vérifier l'existence du dossier

sudo ls -la /opt/tomcat/
# → "Aucun fichier ou dossier de ce type"
Si le processus tourne mais que ses fichiers n'existent pas, c'est la première alerte : namespace isolé.

2. Le "Juge de Paix" : cgroup

C'est LA commande décisive. Regardez le fichier cgroup du processus. 

# Remplacer 10988 par le PID du processus suspect
sudo cat /proc/10988/cgroup
Si vous voyez docker-2a054..., c'est confirmé : le processus est dans le conteneur Docker ID 2a054....

3. Identifier le conteneur

Avec l'ID récupéré (ex: 2a054a740f36), retrouvez le nom et l'image : 

docker inspect 2a054a740f36 --format '{{.Name}} {{.Config.Image}}'
# → /guacamole flcontainers/guacamole

4. Accéder aux fichiers du conteneur (depuis l'hôte)

Vous n'êtes pas obligé de faire un docker exec. Le filesystem du conteneur est accessible via /proc : 

# /proc/<PID>/root/ est la racine du conteneur vue depuis l'hôte
sudo ls -la /proc/10988/root/opt/tomcat/
Cela permet de lire logs et confs sans entrer dans le conteneur.

5. Comprendre les utilisateurs (User Mapping)

Si ps affiche thomasso (UID 1001) mais que le conteneur tourne sous tomcat (UID 1001), c'est normal. Linux stocke l'UID (1001). - Dans le conteneur : /etc/passwd dit 1001 = tomcat. - Sur l'hôte : /etc/passwd dit 1001 = thomasso. ps utilisant le fichier de l'hôte, il affiche "thomasso".

Résumé des commandes

Étape Commande Ce qu'elle révèle
1. Suspicion ls /dossier/incconnu Le dossier n'existe pas → namespace isolé ?
2. Confirmation cat /proc/<PID>/cgroup docker-<ID> → C'est un conteneur !
3. Identification docker inspect <ID> Nom et Image du conteneur.
4. Exploration ls /proc/<PID>/root/ Accès direct aux fichiers du conteneur.
5. Mapping cat /proc/<PID>/status Affiche les UID réels et effectifs.

Tip

PID Parent : Vérifiez le parent (ps -o ppid= -p <PID>). Si le parent est containerd-shim ou un superviseur (comme supervisord) lui-même enfant du moteur de conteneur, c'est une autre piste.

Logs Noyau (dmesg)

La commande dmesg (display message) permet d'afficher le tampon circulaire du noyau (kernel ring buffer). C'est l'outil indispensable pour diagnostiquer des problèmes matériels (disque, réseau, USB) ou des erreurs au démarrage.

Commandes essentielles

Commande Action
dmesg Affiche tous les messages.
dmesg -T Affiche avec des dates lisibles.
dmesg -w Mode suivi en direct (follow).
dmesg -l err,warn Filtre par niveau d'importance (erreurs et warnings seulement).
sudo dmesg -C Vide le tampon.

Exemples pratiques

Diagnostic matériel et USB

Pour voir ce qui se passe quand vous branchez un périphérique : 

dmesg -w

Chasse aux erreurs (OOM Killer, Disques)

Si un processus a été tué par manque de RAM ou si un disque répond mal : 

dmesg -T | grep -E -i "killed|error|fail"

Automatisation SSH (sshpass)

Pour automatiser les scripts utilisant par ex une variable sshpass sans saisie interactive, vous pouvez définir la variable d'environnement SSHPASS de manière permanente dans votre configuration utilisateur.

Procédure de configuration

  1. Ouvrir le fichier de configuration : 

    nano ~/.bashrc

  2. Définir la variable : Ajoutez la ligne suivante à la fin du fichier (en remplaçant par votre mot de passe réel) : 

    export SSHPASS='votre_mot_de_passe'

  3. Appliquer les modifications : Pour rendre la variable disponible immédiatement sans redémarrer le terminal : 

    source ~/.bashrc

Warning

Sécurité : Stocker un mot de passe en clair dans .bashrc est dangereux. On préfère toujours l'utilisation de clés SSH (ssh-copy-id) pour une gestion sécurisée et sans mot de passe.

Analyse Espace Disque (du & df)

Tu peux retrouver plus d'onformation sur la gestiond des disque dans Stockage

Vue d'ensemble partitions (df)

Pour voir rapidement l'espace libre sur les disques montés :

df -h
(Option -h pour "human readable" : affiche en Go/Mo au lieu de blocs)

Analyse détaillée par dossier (du)

La commande du (Disk Usage) permet de savoir quel dossier consomme de la place.

# Taille totale du dossier courant
du -sh .

Top des dossiers les plus volumineux

Pour trouver rapidement ce qui sature votre disque (les "gros consommateurs") :

# Lister la taille des sous-dossiers immédiats, triés par taille décroissante
du -h --max-depth=1 | sort -hr

Ou pour voir le top 10 des fichiers/dossiers dans le répertoire courant :

du -ah . | sort -rh | head -n 10

Astuce : Si disponible, l'outil ncdu offre une interface navigable bien plus pratique que du pour explorer et nettoyer ses disques.

Gestion Utilisateur

Pour mettre un user dans le groupe de sécurité “sudo”

adduser user
usermod -aG sudo user
passwd --lock root

Pour le distrib base sur RHEL pour être sudoer

usermod -aG wheel user

Lister les utilisateurs qui ont des accès

cat /etc/shadow | grep '^[^:]*:[^\*!]'

Détails les expressions régulière :

  1. ^ - Le motif doit être au début de la ligne
  2. [^:]* - Faites correspondre n’importe quel personnage qui n’est pas entre 0 et temps illimité:
  3. : - Faire correspondre le personnage littéralement:
  4. [^\*!] - Correspond à n’importe quel caractère qui n’est pas , une fois.

Permissions et Droits

Note

Les permissions ne sont pas automatiquement récursives ; pour accéder à /mnt/backup, l’utilisateur doit d’abord avoir les droits (traverser) sur /mnt.

La base : ls -l

ls -l nom_du_dossier
Cette commande affiche les permissions sous cette forme : 
drwxr-xr-x  2 utilisateur groupe  4096 date nom_dossier

Structure des permissions : drwxr-xr-x

  • 1er caractère : Type
  • d = dossier
  • - = fichier

  • l = lien symbolique

  • 3 groupes de 3 caractères : 

    rwx | r-x | r-x
 1  |  2  |  3

  • Permissions du propriétaire
  • Permissions du groupe
  • Permissions des autres utilisateurs

Signification des lettres

  • r (read) : Lecture
  • w (write) : Écriture
  • x (execute) : Exécution
  • - : Permission non accordée

Alternatives

Format détaillé

ls -la
* Affiche tous les fichiers (même cachés) * Montre les permissions de tous les éléments

Commande stat

stat nom_du_dossier
* Affiche des informations détaillées * Inclut les permissions en format numérique

Exemple pratique

$ ls -l Documents
drwxr-xr-x 2 john users 4096 Jan 1 12:00 Documents
Signifie : * Le propriétaire (john) peut lire, écrire et exécuter * Le groupe (users) peut lire et exécuter * Les autres peuvent lire et exécuter

Rappel des droits en numérique

  • 4 = lecture (r)
  • 2 = écriture (w)
  • 1 = exécution (x)
  • 0 = aucun droit

Exemple : 755 = rwxr-xr-x

Et pour changer le possesseur du fichier :

chown -R user mondossier/

Exemple de restriction

Exemple d'utilisation si l'ont souhaite restreindre un dossier a root uniquement :

sudo chown -R root /etc/ansible/
sudo chmod 700 -R /etc/ansible/

Sudoers

On peut intéoger via l'outil sudo si un utilisateur est administrateur ou non

sudo -l -U alice

Sa dépend si SSSD est actif ou non mais on peut retrouver les droits dans le fichier sudoers /etc/sudoers /etc/sudoers.d/

Recherche de fichiers et texte

Avec find

Commande de base :

find /chemin/de/recherche -name "nom_du_dossier"

Pour trouver un dossier :

find /chemin/de/recherche -type d -name "nom_du_dossier"

Pour trouver un fichier :

find /chemin/de/recherche -type f -name "nom_du_dossier"

Pour trouver un texte dans le fichier

find . -name "*.py" -type f -exec grep -l "import" {} +

Avec PanDoc combiner

find . -type f -name "*.docx" -exec pandoc -t plain {} \; | grep "mot_clé"

Avec grep

Option -i pour une recherche insensible à la casse.

grep -i "mot_clé" fichier.txt

Recherche de chaînes fixes avec -F et -e :

man ssh | grep -F -e '-f' -e '-N' -e '-D'
  • -F : recherche des chaînes fixes (pas d’expression régulière).
  • -e : chaque -e introduit un motif littéral, même s'il commence par -.

Réseau et Connexions

Utilisation de Nmap

nmap -sP 192.168.1.1-225

scan tout les port si ils sont ouvert

nmap -p- 192.168.1.1

Scan ccomplet de l'appareille port + guest os

sudo nmap -sV -O -v 172.22.215.221

nmap -p445 --script smb-protocols

nmap 192.168.0.0/24

nmap -sn 192.168.0.0/24 -oG nmap_output

Ports et Processus (lsof & ss)

Ces deux outils sont le standard pour l'investigation système et réseau.

lsof (List Open Files)

Car "tout est fichier" sous Linux, lsof voit tout : fichiers, bibliothèques, connexions réseau.

Cas d'usages fréquents :

Commande Usage
lsof -i Lister toutes les connexions réseau actives
lsof -i :8080 Voir spécifiquement qui occupe le port 8080
lsof -p 1234 Voir tout ce que le processus PID 1234 a ouvert
lsof +D /var/log Voir qui écrit dans ce répertoire

La combinaison idéale avec grep : L'option -P (port numérique) et -n (pas de DNS) rend la sortie propre et facile à filtrer.

# Qui écoute sur le port 22 ? (Version précise)
lsof -i -P -n | grep ":22"

# Filtrer les connexions "ESTABLISHED" seulement
lsof -i -P -n | grep "ESTABLISHED"

ss (Socket Statistics)

Le remplaçant moderne de netstat. Il interroge directement le noyau (plus rapide).

La commande à retenir : ss -tulpn * -t TCP / -u UDP * -l Listening (ports en écoute) * -p Processus (affiche le nom du programme - nécessite sudo) * -n Numeric (pas de résolution de nom, essentiel pour grep)

Cas d'usages avec grep :

# Vérifier tout ce qui écoute en TCP et UDP
sudo ss -tulpn

# Isoler un port précis (ex: pour voir si un service a crashé)
sudo ss -tulpn | grep ":80"

# Trouver les connexions établies vers une IP spécifique
ss -tun | grep "192.168.1.50"

# Compter le nombre de connexions actives sur le port 443
ss -tn state established | grep ":443" | wc -l

IPtable

flush iptables :

sudo iptables -P INPUT ACCEPT
sudo iptables -P OUTPUT ACCEPT
sudo iptables -P FORWARD ACCEPT
sudo iptables -F
sudo iptables -X
sudo iptables -t nat -F
sudo iptables -t nat -X
sudo iptables -t mangle -F
sudo iptables -t mangle -X

Voire si tout à été supprimer :

iptables -nvL
Attention un fichier de configuration peut être présent ici :

/etc/iptables/iptables-custom

Connexion SSH

Voir cette page

Sauvegarde

Avec tar

(A revoir en changent l'emplacement de la sauvegarde)

nohup tar cvpzf backup-$(date +%d-%m-%Y).tar.gz --exclude=/backup-$(date +%d-%m-%Y).tar.gz --exclude=/proc --exclude=/tmp --exclude=/mnt --exclude=/dev --exclude=/sys --exclude=/run --exclude=/media --exclude=/var/log --exclude=/usr/src/linux-headers\* --exclude=nohup.out / &

TODO : script de restauration

Avec Rsync

sudo rsync -a --del --info=progress2 --exclude={'/cdrom/*','/dev/*','/lost+found/*','/proc/*','/sys/*','/tmp/*','/run/*','/mnt/*','/media/*'} / "user@prod:/mnt/data/Backup/Linux/albt-usb"

(a vérifier)

sudo rsync -a--delete /backup /system

Exemple de sauvegarde de conteneur docker

rsync -avP --delete /docker/appdata/ /mnt/data/Backup/Docker/

Documentation de rsync

Éditeurs de texte

Utilisation de Vi/Vim

Ouverture et fermeture

vi fichier.txt    # Ouvrir un fichier
:q               # Quitter (si pas de modifications)
:q!              # Quitter sans sauvegarder
:wq              # Sauvegarder et quitter
:w               # Sauvegarder seulement

Les modes essentiels

Mode Normal (par défaut) - Appuyez sur Esc pour y revenir

Mode Insertion - i : insérer avant le curseur - a : insérer après le curseur - o : nouvelle ligne en dessous

Rappel visuel Mode Normal : Le curseur est un bloc → : = commande Mode Insertion : Le curseur est une ligne → : = caractère normal En bas de l'écran tu vois -- INSERT -- quand tu es en mode insertion

h j k l    # ← ↓ ↑ →
w          # mot suivant
b          # mot précédent
0          # début de ligne
$          # fin de ligne
gg         # début du fichier
G          # fin du fichier

Édition rapide

x          # supprimer caractère
dd         # supprimer ligne entière
yy         # copier ligne
p          # coller
u          # annuler (undo)
Ctrl+r     # refaire (redo)

Recherche

/texte     # chercher "texte"
n          # occurrence suivante
N          # occurrence précédente

Astuce

Coincé → Tape Esc puis :q! puis Entrée

Astuces et Divers

Creation de script (Injection de texte)

Exemple d'injection de texte dans un fichier :

cat <<EOF > /etc/wsl.conf
[network]
generateResolvConf = false

[automount]
enabled = true
options = "metadata"
mountFsTab = false
EOF

Force reboot

echo b > /proc/sysrq-trigger

Commande en arrière plan

nohup youtube-dl -o '/mnt/home/user/cloud/Telechargements/%(title)s.%(ext)s' -q https://www.youtube.com/watch?v=GSUmEZPmNPg &> /dev/null &

Ajouter une commande personnalisé (alias)

  1. Editer le fichier : /etc/bash.bashrc
  2. Ajouter une ligne au bas du fichier au format suivant : <your_custom_command_name>=‘<command_to_be_executed>

Source : Medium

Sudo sans mot de passe

Exemple : 

sudo tee -a /etc/sudoers >/dev/null <<'EOF'
user ALL=(ALL) NOPASSWD: ALL
EOF

Source : linuxtechi

Traitement de sortit de texte

Utilitaires de base pour le flux de texte

Commande Action Exemple
tee Copie l'entrée vers la sortie standard ET dans un fichier ls | tee output.txt
head Affiche le début d'un fichier (10 lignes par défaut) head -n 5 fichier.txt
tail Affiche la fin d'un fichier tail -f /var/log/syslog (suivi en direct)
tac Affiche le contenu dans l'ordre inverse (inverse de cat) tac logs.txt
grep Filtre les lignes contenant un texte spécifique grep "ERROR" app.log
wc Compte les lignes (-l), les mots ou les caractères ls | wc -l
sort Trie les lignes de texte cat liste.txt | sort
uniq Supprime les doublons successifs sort fichier.txt | uniq
column Formate la sortie en colonnes lisibles mount | column -t

Exemples de combinaisons avec le pipe |

# Compter le nombre de fichiers .txt dans le répertoire
ls | grep ".txt" | wc -l

# Afficher les 5 dernières erreurs d'un fichier de log
grep "ERROR" /var/log/syslog | tail -n 5

# Trier une liste, supprimer les doublons et sauvegarder le résultat
cat liste.txt | sort | uniq | tee liste_propre.txt

# Formater la liste des partitions et filtrer les disques ext4
mount | column -t | grep "ext4"

Ajouter une application au chemin d'execution (PATH)

Pour que vous puissiez exécuter l'application zeek de n'importe où dans le terminal sans devoir naviguer jusqu'à son répertoire /opt/zeek/bin

nano ~/.bashrc

puit insérer la ligne suivante :

export PATH="/opt/zeek/bin:$PATH"

Screen et Partage de Terminal

L'outil standard est GNU Screen. Il permet de lancer des processus en arrière-plan (comme nohup mais réattachable) et de partager son terminal.

Commandes de base

Commande Action
screen Lance une nouvelle session
screen -S nom Lance une session nommée "nom"
Ctrl+a puis d Détache la session (la laisse tourner en fond)
screen -ls Liste les sessions actives
screen -r nom Réattache (reprend) une session
screen -x nom Se connecte à une session déjà ouverte (Multi-écran)

Partager son terminal (Session partagée)

Pour qu'un autre utilisateur voie et interagisse avec votre terminal en temps réel :

  1. L'hôte lance une session : screen -S masession
  2. L'hôte active le multi-user (dans screen, taper Ctrl+a puis :) : 
    :multiuser on
:acladd lartre_user
  3. L'invité se connecte : screen -x hote/masession

Note

Pour un partage rapide via internet sans configuration, regardez du côté de tmate (basé sur tmux).

Aide Rapide : TLDR (Too Long; Didn't Read)

L'outil tldr (Too Long; Didn't Read) est une excellente alternative aux pages man classiques. Alors que man est exhaustif et parfois décourageant, tldr se contente de lister les commandes les plus couramment utilisées avec des exemples concrets et faciles à comprendre.

Au lieu de chercher dans la longue documentation avec man tar, vous pouvez simplement taper :

tldr tar

Il vous donnera directement les 4 ou 5 commandes les plus utilisées pour compresser, décompresser ou extraire un fichier sans vous perdre dans la documentation.

Tip

Lors de la première utilisation, il est parfois nécessaire de mettre à jour le cache local des pages avec la commande tldr --update ou tldr -u.