10 commandes et raccourcis Linux simples pour aller plus vite dans le terminal, éviter de retaper les mêmes choses et bosser plus proprement.
10 commandes Linux utiles que j’utilise vraiment au quotidien
Pas des commandes magiques, juste des petits réflexes qui font gagner du temps quand on vit souvent dans un terminal.
Je passe pas mal de temps dans des shells Linux, que ce soit sur mes machines, mes VPS, des conteneurs Docker ou des petites VM de test.
Et au bout d’un moment, on se rend compte que ce ne sont pas toujours les grosses commandes compliquées qui font gagner le plus de temps. Souvent, ce sont des petits réflexes : relancer une commande avec les bons droits, retrouver une ancienne commande, garder une session ouverte, éviter de retaper un chemin, envoyer un job en arrière-plan.
Je suis tombé sur cet article qui liste plusieurs astuces utiles côté terminal :
11 Useful Linux Terminal Tricks That Actually Save Time
Je reprends l’idée ici, à ma sauce, avec 10 commandes et raccourcis que je trouve vraiment utiles dans un usage Linux quotidien, surtout dans un contexte homelab.
1. Relancer la dernière commande avec sudo
C’est probablement un des classiques les plus rentables.
On lance une commande, elle échoue parce qu’il manque les droits root, et au lieu de tout retaper, on peut demander au shell de reprendre la commande précédente avec les droits administrateur.
sudo !!
Le `!!` représente la commande précédente dans l’historique du shell.
Par exemple, si la commande précédente était `apt update`, alors cette astuce revient à relancer `apt update` avec `sudo` devant.
Très pratique, mais à utiliser avec un minimum d’attention. Avant de relancer une commande précédente avec sudo, il faut être sûr de ce qu’elle contenait vraiment. Le terminal n’est pas un endroit où cliquer sur suivant sans regarder.
2. Rechercher dans l’historique avec Ctrl+R
`Ctrl+R` n’est pas une commande à taper, mais c’est un raccourci Bash/Zsh que j’utilise tout le temps.
Il permet de chercher dans les commandes déjà lancées.
Ctrl+R
Ensuite, on tape un morceau de la commande recherchée.
compose logs
Le shell retrouve une commande précédente qui contient ce texte.
Quelques réflexes utiles :
- Entrée pour exécuter directement la commande trouvée
- flèche droite ou gauche pour l’éditer avant exécution
- Ctrl+R encore pour passer au résultat précédent
- Ctrl+G pour annuler la recherche
C’est tout simple, mais quand on administre souvent les mêmes services, c’est extrêmement efficace. Typiquement, pour retrouver une commande Docker, SSH, rsync ou systemctl tapée il y a deux jours, ça évite de fouiller dans sa mémoire.
Petit conseil perso : si tu fais beaucoup de commandes sensibles avec tokens, mots de passe ou secrets, évite de les laisser traîner dans l’historique. Un shell pratique ne doit pas devenir un fichier de fuite bien rangé.
3. Afficher les anciennes commandes avec history
La commande `history` affiche les commandes déjà utilisées dans le shell.
history
On peut aussi filtrer avec `grep`.
history | grep ssh
history | grep docker
history | grep rsync
C’est utile quand on ne sait plus exactement quelle commande avait marché la dernière fois.
On peut aussi relancer une commande par son numéro.
!142
Ici, Bash relance la commande numéro 142 de l’historique.
Personnellement, je préfère souvent `Ctrl+R`, parce que ça permet de relire et modifier avant de lancer. Mais `history` reste très pratique pour fouiller, surtout quand on cherche une ancienne commande avec un bout de chemin ou un nom de service.
● Un shell compatible, comme Bash ou Zsh
● Un historique activé
Sur un serveur partagé ou sensible, l’historique doit être traité comme une donnée potentiellement confidentielle. On y retrouve parfois beaucoup trop d’informations.
4. Revenir au dossier précédent avec cd -
Celui-là est simple, mais je l’aime beaucoup.
Quand on navigue entre deux dossiers, `cd -` permet de revenir au dossier précédent.
cd -
Et si on relance la même commande, on revient au dossier d’avant.
C’est pratique quand on alterne entre un dossier de config et un dossier de logs.
cd /etc/nginx/sites-available
cd /var/log/nginx
cd -
Ça évite de retaper des chemins longs, surtout sur des serveurs où l’autocomplétion n’est pas toujours confortable.
Exemple typique : je modifie une conf Nginx, je vais lire les logs, puis je reviens directement dans le dossier de configuration.
cd /etc/nginx
cd /var/log/nginx
cd -
Ce n’est pas spectaculaire, mais c’est exactement le genre de petit réflexe qui rend le terminal moins pénible.
5. Créer ses raccourcis avec alias
Les alias permettent de créer des raccourcis pour des commandes qu’on tape souvent.
Exemple classique :
alias ll='ls -lah'
Après ça, on peut taper `ll` au lieu de `ls -lah`.
Quelques alias que je trouve utiles :
alias gs='git status'
alias dc='docker compose'
alias ports='ss -tulpn'
alias update='sudo apt update && sudo apt upgrade'
Pour rendre un alias permanent, on l’ajoute généralement dans le fichier de configuration du shell.
Avec Bash :
nano ~/.bashrc
Avec Zsh :
nano ~/.zshrc
Puis on recharge le fichier.
source ~/.bashrc
Ou avec Zsh :
source ~/.zshrc
Les alias sont pratiques pour les commandes fréquentes, mais je préfère les garder lisibles. Un bon alias doit aider à taper moins, pas cacher une commande incompréhensible.
Je conseille d’éviter les alias trop destructeurs. Un raccourci vers une commande de suppression ou de nettoyage agressif, c’est confortable jusqu’au jour où ça part trop vite.
6. Créer une mini commande avec une fonction shell
Quand un alias ne suffit plus, on peut créer une fonction shell.
Exemple simple : créer une fonction pour entrer dans un dossier et lister son contenu directement.
cdd() { cd "$1" && ls -lah; }
Ensuite, on peut l’utiliser comme ça :
cdd /var/log
La fonction fait deux choses :
- elle entre dans le dossier demandé
- elle affiche son contenu
Autre exemple utile en homelab : afficher rapidement les logs d’un service systemd.
jlog() { journalctl -u "$1" -f; }
Ensuite :
jlog nginx
Cette commande revient à suivre les logs du service `nginx`.
Les fonctions peuvent être placées dans `~/.bashrc` ou `~/.zshrc`, comme les alias.
On peut aussi faire une petite fonction pour redémarrer un service puis afficher son état.
srestart() { sudo systemctl restart "$1" && systemctl status "$1"; }
Puis :
srestart nginx
Dès qu’une fonction commence à faire beaucoup de choses, je préfère la transformer en vrai script dans `~/bin` ou `/usr/local/bin`. Le shell doit rester pratique, pas devenir un placard rempli de logique cachée.
7. Gérer les tâches avec jobs, bg et fg
Quand une commande tourne au premier plan, on peut parfois vouloir récupérer le terminal sans tuer le processus.
Exemple :
ping 1.1.1.1
Pour suspendre la commande :
Ctrl+Z
Ensuite, pour voir les tâches suspendues :
jobs
Pour relancer la tâche en arrière-plan :
bg
Pour la ramener au premier plan :
fg
Résultat typique de `jobs` :
[1]+ Stopped ping 1.1.1.1
On peut cibler précisément une tâche avec son numéro.
bg %1
fg %1
C’est utile avec des scripts longs, des transferts, des commandes de debug, ou simplement quand on a lancé quelque chose dans le mauvais terminal.
● Un shell interactif
● Une commande lancée dans le terminal courant
Pour les vraies tâches longues sur serveur distant, je préfère `tmux` ou `systemd`. Les jobs shell sont pratiques, mais pas faits pour survivre proprement à toutes les déconnexions SSH.
8. Garder une session vivante avec tmux
`tmux` est un multiplexeur de terminal.
Dit plus simplement : il permet d’avoir plusieurs terminaux dans une seule session, et surtout de détacher puis rattacher cette session plus tard.
Installation sur Debian ou Ubuntu :
sudo apt install tmux
Créer une session :
tmux
Créer une session nommée :
tmux new -s maintenance
Détacher la session :
Ctrl+B puis D
Lister les sessions :
tmux ls
Revenir dans une session :
tmux attach -t maintenance
C’est très utile sur un serveur distant. On peut lancer une mise à jour, une compilation, une sauvegarde ou une commande longue, se déconnecter, puis revenir plus tard.
Exemple de session dédiée à une sauvegarde :
tmux new -s backup
rsync -avh /data/ /mnt/backup/
Puis on détache avec `Ctrl+B puis D`, et on revient plus tard dans la session.
tmux attach -t backup
Pour moi, `tmux` fait partie des outils à installer rapidement sur un serveur. Une connexion SSH qui saute pendant une opération longue, ça arrive toujours au mauvais moment.
9. Écrire dans un fichier avec tee
`tee` permet d’écrire la sortie d’une commande dans un fichier tout en l’affichant dans le terminal.
ls -lah | tee listing.txt
La sortie est affichée à l’écran et sauvegardée dans `listing.txt`.
C’est aussi très utile avec `sudo`, quand une redirection classique ne marche pas comme prévu.
Cette approche peut échouer sur un fichier système, même si on met `sudo` devant `echo`, parce que la redirection est gérée par le shell courant.
sudo echo "test" > /etc/example.conf
Avec `tee`, on peut faire :
echo "test" | sudo tee /etc/example.conf
Pour ajouter à la fin du fichier au lieu de l’écraser :
echo "test" | sudo tee -a /etc/example.conf
Cas pratique : ajouter une ligne dans un fichier système.
echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
On peut aussi l’utiliser pour garder une trace d’une sortie de commande.
docker compose logs --tail=100 | tee logs-docker.txt
Attention à `tee` sans `-a` : il écrase le fichier cible. Quand on touche à `/etc`, ça vaut le coup de respirer deux secondes avant d’appuyer sur Entrée.
10. Transformer une liste en actions avec xargs
`xargs` sert à prendre une liste d’éléments en entrée et à exécuter une commande dessus.
Exemple simple, volontairement non destructeur :
printf "a.txt\nb.txt\n" | xargs echo
`xargs` récupère la liste en entrée et la passe comme arguments à `echo`.
Exemple plus utile avec Docker : lister les conteneurs arrêtés.
docker ps -aq -f status=exited
Puis les supprimer :
docker ps -aq -f status=exited | xargs docker rm
Autre exemple : chercher des fichiers `.log` et afficher leur taille.
find /var/log -name "*.log" | xargs du -h
Avec des noms de fichiers contenant des espaces, il vaut mieux utiliser `-print0` côté `find` et `-0` côté `xargs`.
find . -name "*.log" -print0 | xargs -0 du -h
Avant une commande destructive, je préfère tester avec `echo`.
find . -name "*.tmp" -print0 | xargs -0 echo rm
Si la sortie est correcte, on peut ensuite retirer `echo`.
● Une commande qui produit une liste
● Une commande qui accepte des arguments
Toujours tester une commande `xargs` avec une action non destructive avant de supprimer ou modifier. C’est rapide, et ça évite les mauvaises surprises.
Bonus : utiliser Tab pour éviter les fautes bêtes
Ce n’est pas une commande, mais c’est probablement l’habitude la plus importante.
Quand on tape un chemin, une commande, un nom de service ou un fichier, la touche Tab complète automatiquement quand c’est possible.
Exemple :
cd /var/lo
Avec Tab, le shell peut compléter vers `/var/log`.
Même logique avec des commandes ou des services.
systemctl status ng
Tab peut proposer ou compléter `nginx` si le service existe.
Appuyer deux fois sur Tab affiche souvent les possibilités disponibles.
C’est rapide, mais surtout ça évite les fautes de frappe dans les chemins et les noms de services.
Conclusion
Ces commandes ne remplacent pas une bonne compréhension de Linux, mais elles rendent le terminal beaucoup plus agréable au quotidien.
Celles que j’utilise le plus souvent :
- `sudo !!` pour corriger vite un oubli de droits
- `Ctrl+R` pour retrouver une commande
- `cd -` pour naviguer entre deux dossiers
- `tmux` pour les sessions SSH sérieuses
- `tee` pour écrire proprement dans des fichiers avec sudo
- `xargs` pour automatiser des actions sur une liste
Le vrai gain, ce n’est pas d’apprendre 200 commandes par coeur.
C’est plutôt de construire petit à petit une boîte à outils fiable, lisible, et pas trop dangereuse. Surtout quand on travaille sur des machines qu’on aime bien, ou qu’on n’a pas envie de réinstaller un dimanche soir.