Astuces Bash pour tous les jours en ligne de commande

En tant que shell par défaut pour de nombreuses variantes Linux et Unix, Bash inclut une grande variété de fonctionnalités sous-utilisées, il était donc difficile de décider de quoi discuter. En fin de compte, j'ai décidé de me concentrer sur les conseils de Bash qui facilitent les activités quotidiennes.

En tant que consultant, je vois une pluralité d'environnements et de styles de travail divers. J'ai tiré parti de cette expérience pour réduire les conseils à quatre grandes catégories :astuces de terminal et de ligne, navigation et fichiers, historique et commandes utiles. Ces catégories sont complètement arbitraires et servent plus à organiser ma propre pensée qu'à une quelconque classification définitive. De nombreux conseils inclus ici peuvent subjectivement appartenir à plusieurs catégories.

Sans plus tarder, voici quelques-unes des astuces Bash les plus utiles que j'ai rencontrées.

Travailler avec l'historique de Bash

L'un des meilleurs moyens d'augmenter votre productivité est d'apprendre à utiliser l'historique Bash plus efficacement. Dans cet esprit, l'une des modifications les plus importantes que vous pouvez effectuer dans un environnement multi-utilisateurs consiste peut-être à activer le histappend option à votre shell. Pour cela, exécutez simplement la commande suivante :

shopt -s histappend  

Cela permet à plusieurs sessions de terminal d'écrire dans l'historique en même temps. Dans la plupart des environnements, cette option n'est pas activé. Cela signifie que les historiques sont souvent perdus si vous avez plusieurs sessions Bash ouvertes (soit localement, soit via SSH).

Une autre tâche courante consiste à répéter la dernière commande avec sudo . Par exemple, supposons que vous souhaitiez créer un répertoire mkdir /etc/ansible/facts.d . Sauf si vous êtes root, cette commande échouera. D'après ce que j'ai observé, la plupart des utilisateurs ont atteint le up flèche, faites défiler jusqu'au début de la ligne et ajoutez le sudo commande. Il existe un moyen plus simple. Exécutez simplement la commande comme ceci :

sudo !! 

Bash exécutera sudo puis l'intégralité de la commande précédente. Voici exactement à quoi cela ressemble lorsqu'il est exécuté en séquence :

[user@centos ~]$ mkdir -p /etc/ansible/facts.d
mkdir :impossible de créer le répertoire '/etc/ansible' :autorisation refusée

[user@ centos ~]$ sudo !!
sudo mkdir -p /etc/ansible/facts.d

Lorsque le !! est exécuté, la commande complète est renvoyée au terminal afin que vous sachiez ce qui vient d'être exécuté.

Similaire mais utilisé beaucoup moins fréquemment est le !* raccourci. Cela indique à Bash que vous voulez tous les *arguments* de la commande précédente à répéter dans la commande en cours. Cela peut être utile pour une commande qui a beaucoup d'arguments que vous souhaitez réutiliser. Un exemple simple consiste à créer un ensemble de fichiers, puis à modifier les autorisations sur ceux-ci :

[user@centos tmp]$ touch fichier1 fichier2 fichier3 fichier4
[user@centos tmp]$ chmod 777 !*
chmod 777 fichier1 fichier2 fichier3 fichier4

Il n'est utile que dans un ensemble de circonstances spécifiques, mais il peut vous épargner quelques frappes.

En parlant de sauvegarde des frappes, parlons de la recherche de commandes dans votre historique. La plupart des utilisateurs feront quelque chose comme ceci :

history |grep <some command> 

Cependant, il existe un moyen plus simple de rechercher votre historique. Si vous appuyez sur

ctrl + r 

Bash effectuera une recherche inversée de votre historique. Lorsque vous commencez à taper, les résultats commencent à apparaître. Par exemple :

(reverse-i-search)`hist': shopt -s histappend 

Dans l'exemple ci-dessus, j'ai tapé hist et il correspondait au shopt commande que nous avons couverte plus tôt. Si vous continuez à appuyer sur ctrl + r , Bash continuera à rechercher en arrière dans toutes les autres correspondances.

Notre dernière astuce n'est pas tant une astuce qu'une commande utile que vous pouvez utiliser pour compter et afficher les commandes les plus utilisées dans votre historique.

[user@centos tmp]$ historique | awk 'COMMENCER {FS="[ \t]+|\\|"} {imprimer $3}' | trier | uniq-c | sort -nr | head 
81 ssh
50 sudo
46 ls
45 ping
39 cd
29 nvidia-xrun
20 nmap
19 exporter

Dans cet exemple, vous pouvez voir que ssh est de loin la commande la plus utilisée dans mon historique pour le moment.

Navigation et nommage des fichiers

Plus de ressources Linux

• Aide-mémoire des commandes Linux
• Aide-mémoire des commandes Linux avancées
• Cours en ligne gratuit :Présentation technique de RHEL
• Aide-mémoire sur le réseau Linux
• Aide-mémoire SELinux
• Aide-mémoire sur les commandes courantes de Linux
• Que sont les conteneurs Linux ?
• Nos derniers articles Linux

Vous savez probablement déjà que si vous tapez une commande, un nom de fichier ou un nom de dossier, vous pouvez appuyer sur l'onglet tab clé une fois pour compléter le libellé pour vous. Cela fonctionne s'il existe une seule correspondance exacte. Cependant, vous ne le savez peut-être pas si vous appuyez sur tab deux fois, il vous montrera toutes les correspondances en fonction de ce que vous avez tapé. Par exemple :

[user@centos tmp]$ cd /lib 
lib/ lib64/ 

Cela peut être très utile pour la navigation dans le système de fichiers. Une autre astuce utile consiste à activer cdspell dans ta coquille. Vous pouvez le faire en émettant le shopt -s cdspell commande. Cela vous aidera à corriger vos fautes :

[user@centos etc]$ cd /tpm
/tmp
[user@centos tmp]$ cd /ect
/etc

Ce n'est pas parfait, mais chaque petit geste compte !

Une fois que vous avez réussi à changer de répertoire, que se passe-t-il si vous devez revenir à votre répertoire précédent ? Ce n'est pas un gros problème si vous n'êtes pas très profond dans l'arborescence des répertoires. Mais si vous êtes dans un chemin assez profond, tel que /var/lib/flatpak/exports/share/applications/ , vous pouvez taper :

cd /va<tab>/lib/fla<tab>/ex<tab>/sh<tab>/app<tab> 

Heureusement, Bash se souvient de votre répertoire précédent, et vous pouvez y revenir en tapant simplement cd - . Voici à quoi cela ressemblerait :

[applications utilisateur@centos]$ pwd
/var/lib/flatpak/exports/share/applications

[applications utilisateur@centos]$ cd /tmp
[ user@centos tmp]$ pwd
/tmp

[user@centos tmp]$ cd -
/var/lib/flatpak/exports/share/applications

C'est bien beau, mais que se passe-t-il si vous avez un tas de répertoires dans lesquels vous voulez naviguer facilement ? Bash vous a également couvert là-bas. Vous pouvez définir une variable qui vous aidera à naviguer plus efficacement. Voici un exemple :

[applications utilisateur@centos]$ export CDPATH='~:/var/log:/etc'
[applications utilisateur@centos]$ cd hp
/etc/hp

[utilisateur@centos hp]$ cd Téléchargements
/home/user/Téléchargements

[utilisateur@centos Téléchargements]$ cd ansible
/etc/ansible

[user@centos Downloads]$ cd journal
/var/log/journal

Dans l'exemple ci-dessus, j'ai défini mon répertoire personnel (indiqué par le tilde :~ ), /var/log et /etc . Tout ce qui se trouve au niveau supérieur de ces répertoires sera rempli automatiquement lorsque vous les référencerez. Répertoires qui ne sont pas à la base des répertoires listés dans CDPATH ne sera pas trouvé. Si, par exemple, le répertoire que vous recherchez était /etc/ansible/facts.d/ cela ne se terminerait pas en tapant cd facts.d . En effet, alors que le répertoire ansible se trouve sous /etc , facts.d n'est pas. Par conséquent, CDPATH est utile pour accéder au sommet d'une arborescence à laquelle vous accédez fréquemment, mais cela peut devenir fastidieux à gérer lorsque vous parcourez une grande structure de dossiers.

Enfin, parlons de deux cas d'utilisation courants que tout le monde fait à un moment donné :modifier une extension de fichier et renommer des fichiers. À première vue, cela peut sembler la même chose, mais Bash propose quelques astuces différentes pour accomplir ces tâches.

Bien qu'il puisse s'agir d'une opération "vers le bas", la plupart des utilisateurs doivent à un moment donné créer une copie rapide d'un fichier sur lequel ils travaillent. La plupart copieront le nom de fichier exactement et ajouteront simplement une extension de fichier comme .old ou .bak . Il existe un raccourci rapide pour cela dans Bash. Supposons que vous ayez un nom de fichier comme spideroak_inotify_db.07pkh3 dont vous souhaitez conserver une copie. Vous pouvez taper :

cp spideroak_inotify_db.07pkh3 spideroak_inotify_db.07pkh3.bak 

Vous pouvez effectuer un travail rapide en utilisant des opérations de copier/coller, en utilisant l'onglet complet, en utilisant éventuellement l'un des raccourcis pour répéter un argument, ou en tapant simplement le tout. Cependant, la commande ci-dessous devrait s'avérer encore plus rapide une fois que vous vous serez habitué à la saisir :

cp spideroak_inotify_db.07pkh3{,.old} 

Ceci (comme vous pouvez le deviner) copie le fichier en ajoutant le .old extension de fichier au fichier. C'est super, me direz-vous, mais je veux renommer un grand nombre de fichiers à la fois. Bien sûr, vous pourriez écrivez une boucle for pour traiter ces problèmes (et en fait, je le fais souvent pour quelque chose de compliqué) mais pourquoi le feriez-vous alors qu'il existe un utilitaire pratique appelé rename ? Il y a une certaine différence dans l'utilisation de cet utilitaire entre Debian/Ubuntu et CentOS/Arch. Le changement de nom basé sur Debian utilise une syntaxe de type SED :

user@ubuntu-1604:/tmp$ pour x dans `seq 1 5` ; touchez old_text_file_${x}.txt ; done

user@ubuntu-1604 :/tmp$ ls old_text_file_*
old_text_file_1.txt old_text_file_3.txt old_text_file_5.txt
old_text_file_2.txt old_text_file_4.txt

user@ubuntu-1604 :/tmp$ rename 's/old_text_file/shiney_new_doc/' *.txt

user@ubuntu-1604 :/tmp$ ls shiney_new_doc_*
shiney_new_doc_1.txt shiney_new_doc_3.txt shiney_new_doc_5.txt
shiney_new_doc_2.txt shiney_new_doc_4.txt

Sur une boîte CentOS ou Arch, cela ressemblerait à :

[user@centos /tmp]$ pour x dans `seq 1 5` ; touchez old_text_file_${x}.txt ; terminé

[user@centos /tmp]$ ls old_text_file_*
old_text_file_1.txt old_text_file_3.txt old_text_file_5.txt
old_text_file_2.txt old_text_file_4.txt

[user@centos tmp]$ renommer old_text_file centos_new_doc *.txt

[user@centos tmp]$ ls centos_new_doc_*
centos_new_doc_1.txt centos_new_doc_3.txt centos_new_doc_5.txt
centos_new_doc_2 .txt centos_new_doc_4.txt

Les raccourcis clavier Bash

Bash a beaucoup de raccourcis clavier intégrés. Vous pouvez en trouver une liste en tapant bind -p . J'ai pensé qu'il serait utile d'en souligner plusieurs, bien que certains soient peut-être bien connus.

• ctrl + _ (annuler)
• ctrl + t (échanger deux caractères)
• ALT + t (échanger deux mots)
• ALT + . (imprime le dernier argument de la commande précédente)
• ctrl + x + * (développer glob/étoile)
• ctrl + flèche (avancer d'un mot)
• ALT + f (avancer d'un mot)
• ALT + b (reculer d'un mot)
• ctrl + x suivi de ctrl + e (ouvre la chaîne de commande dans un éditeur afin que vous puissiez la modifier avant l'exécution)
• ctrl + e (déplacer le curseur à la fin)
• ctrl + a (déplacer le curseur pour commencer)
• ctrl + xx (déplacer vers l'extrémité opposée de la ligne)
• ctrl + u (coupe tout avant le curseur)
• ctrl + k (coupe tout après le curseur)
• ctrl + y (colle depuis le tampon)
• ctrl + l (L minuscule, efface l'écran)

Je ne parlerai pas des plus évidentes. Cependant, certains des raccourcis les plus utiles que j'ai trouvés sont ceux qui vous permettent de supprimer des mots (ou des sections de texte) et de les annuler. Supposons que vous alliez arrêter un tas de services en utilisant systemd , mais vous ne vouliez en démarrer que quelques-unes après la fin d'une opération. Vous pourriez faire quelque chose comme ceci :

systemctl stop httpd mariadb nfs smbd

Et si vous en supprimiez un de trop ? Pas de problème, utilisez simplement ctrl + _ pour annuler la dernière modification.

Les autres commandes de coupe permettent de tout supprimer rapidement du curseur à la fin ou au début de la ligne (en utilisant Ctrl + k et Ctrl + u , respectivement). Cela a l'avantage supplémentaire de placer le texte coupé dans le tampon du terminal afin que vous puissiez le coller plus tard (en utilisant ctrl + y ). Ces commandes sont difficiles à démontrer ici, je vous encourage donc fortement à les essayer par vous-même.

Enfin, j'aimerais mentionner une combinaison de touches rarement utilisée qui peut être extrêmement pratique dans des environnements confinés tels que des conteneurs. Si jamais une commande semble brouillée par la sortie précédente, il existe une solution :appuyez sur ctrl + x + ctrl + e ouvrira la commande dans l'éditeur défini dans la variable d'environnement EDITOR. Cela vous permettra de modifier une commande longue ou brouillée dans un éditeur de texte qui peut (potentiellement) envelopper du texte. Enregistrer votre travail et quitter, comme vous le feriez lorsque vous travaillez sur un fichier normal, exécutera la commande en quittant l'éditeur.

Conseils divers

Vous constaterez peut-être que l'affichage des couleurs dans votre shell Bash peut améliorer votre expérience. Si vous utilisez une session pour laquelle la colorisation n'est pas activée, voici une série de commandes que vous pouvez placer dans votre .bash_profile pour ajouter de la couleur à votre séance. Celles-ci sont assez simples et ne devraient pas nécessiter d'explications approfondies :

# enable colors
eval "`dircolors -b`"

# force ls à toujours utiliser des indicateurs de couleur et de type
alias ls='ls -hF --color =auto'

# fait fonctionner la commande dir un peu comme sous Windows (format long)
alias dir='ls --color=auto --format=long'

# faites en sorte que grep surligne les résultats en utilisant la couleur
export GREP_OPTIONS='--color=auto'

# Ajoutez de la couleur aux pages LESS/MAN
export LESS_TERMCAP_mb=$' \E[01;31m'
exporter LESS_TERMCAP_md=$'\E[01;33m'
exporter LESS_TERMCAP_me=$'\E[0m'
exporter LESS_TERMCAP_se=$'\E[0m ' 
exporter LESS_TERMCAP_so=$'\E[01;42;30m'
exporter LESS_TERMCAP_ue=$'\E[0m'
exporter LESS_TERMCAP_us=$'\E[01;36m' 

 En plus d'ajuster les différentes options de Bash, vous pouvez également utiliser quelques astuces intéressantes pour gagner du temps. Par exemple, pour exécuter deux commandes consécutives, quel que soit le statut de sortie de chacune, utilisez le ; pour séparer les commandes, comme ci-dessous :
 
[user@centos /tmp]$ du -hsc * ; df -h 
 

 Cela calcule simplement la quantité d'espace occupée par chaque fichier dans le répertoire actuel (et la somme), puis interroge le système sur l'utilisation du disque par périphérique de bloc. Ces commandes s'exécuteront quelles que soient les erreurs générées par le du commande.
 

 Que se passe-t-il si vous souhaitez qu'une action soit entreprise après l'exécution réussie de la première commande ? Vous pouvez utiliser le && raccourci pour indiquer que vous souhaitez exécuter la deuxième commande uniquement si la première commande renvoie un état de sortie réussi. Par exemple, supposons que vous souhaitiez redémarrer une machine uniquement si les mises à jour ont réussi :
 
[root@arch ~]$ pacman -Syu --noconfirm && reboot 
 

 Parfois, lors de l'exécution d'une commande, vous souhaiterez peut-être capturer sa sortie. La plupart des gens connaissent le tee commande, qui copiera la sortie standard à la fois dans le terminal et dans un fichier. Toutefois, si vous souhaitez capturer une sortie plus complexe à partir, par exemple, de strace , vous devrez commencer à utiliser la redirection d'E/S. Les détails de la redirection d'E/S dépassent le cadre de ce court article, mais pour nos besoins, nous nous intéressons à STDOUT et STDERR . La meilleure façon de capturer exactement ce que vous voyez est de combiner les deux dans un seul fichier. Pour cela, utilisez le 2>&1 redirection.
 
[root@arch ~]$ strace -p 1140 > strace_output.txt 2>&1 
 

 Cela placera toutes les sorties pertinentes dans un fichier appelé strace_output.txt pour visionner plus tard.
 

 Parfois, lors d'une commande de longue durée, vous devrez peut-être interrompre l'exécution d'une tâche. Vous pouvez utiliser le raccourci 'stop' ctrl + z arrêter (mais pas tuer) un travail. Le travail est ajouté à la file d'attente des travaux, mais vous ne le verrez plus tant que vous ne le reprendrez pas. Ce travail peut être repris ultérieurement en utilisant la commande de premier plan fg .
 

 De plus, vous pouvez aussi simplement suspendre une tâche avec ctrl + s . Le travail et sa sortie restent au premier plan du terminal et l'utilisation du shell n'est pas retourné à l'utilisateur. Le travail peut être repris en appuyant sur ctrl + q .
 

 Si vous travaillez dans un environnement graphique avec de nombreux terminaux ouverts, vous trouverez peut-être pratique d'avoir des raccourcis clavier pour copier et coller la sortie. Pour cela, utilisez les raccourcis suivants :
 
# Copie le texte surligné
ctrl + shift + c 

# Colle le texte dans le tampon
ctrl + shift + v
 

 Supposons que dans la sortie d'une commande en cours d'exécution, vous voyez une autre commande en cours d'exécution et que vous souhaitez obtenir plus d'informations. Il y a quelques façons de le faire. Si cette commande se trouve quelque part dans votre chemin, vous pouvez exécuter le which commande pour savoir où se trouve cette commande sur votre disque :
 
[root@arch ~]$ qui ls
/usr/bin/ls
 

 Avec ces informations, vous pouvez inspecter le binaire avec le file commande :
 
[root@arch ~]$ file /usr/bin/ls
/usr/bin/ls :ELF 64-bit LSB pie executable x86-64, version 1 (SYSV), dynamiquement lié, interpréteur / lib64/ld-linux-x86-64.so.2, pour GNU/Linux 3.2.0, BuildID[sha1]=d4e02b88e596e4f82c6cc62a5bc4ce5827209a49, supprimé
 

 Vous pouvez voir toutes sortes d'informations, mais la plus importante pour la plupart des utilisateurs est le ELF 64-bit LSB absurdité. Cela signifie essentiellement qu'il s'agit d'un binaire précompilé par opposition à un script ou à un autre type d'exécutable. Un outil connexe que vous pouvez utiliser pour inspecter les commandes est la command outil lui-même. Exécutez simplement command -V <command> vous donnera différents types d'informations :
 
[root@arch ~]$ command -V ls
ls est aliasé à `ls --color=auto` 

[root@arch ~]$ command -V bash
bash est /usr/bin/bash

[root@arch ~]$ command -V shopt
shopt est un shell intégré
 

 Enfin et surtout, l'une de mes astuces préférées, en particulier lorsque je travaille avec des conteneurs ou dans des environnements où j'ai peu de connaissances ou de contrôle, est le echo commande. Cette commande peut être utilisée pour tout faire, depuis la vérification pour s'assurer que votre for loop exécutera la séquence attendue pour vous permettre de vérifier si les ports distants sont ouverts. La syntaxe est très simple pour vérifier un port ouvert :echo > /dev/<udp or tcp>/<server ip>/<port> . Par exemple :
 
user@ubuntu-1604 :~$ echo> /dev/tcp/192.168.99.99/222
-bash :connect :connexion refusée
-bash :/dev/tcp/192.168.99.99/ 222 :Connexion refusée

user@ubuntu-1604 :~$ echo> /dev/tcp/192.168.99.99/22
 

 Si le port est fermé au type de connexion que vous essayez d'établir, vous obtiendrez un Connection refused message. Si le paquet est envoyé avec succès, il n'y aura pas de sortie.
 

 J'espère que ces conseils rendront Bash plus efficace et agréable à utiliser. Il y a beaucoup plus d'astuces cachées dans Bash que celles que j'ai énumérées ici. Quels sont certains de vos favoris ?
 
Annexe 1. Liste des trucs et astuces abordés
 
# Lié à l'historique 
ctrl + r (recherche inversée)
!! (réexécuter la dernière commande)
!* (réutiliser les arguments de la commande précédente)
!$ (utiliser le dernier argument de la dernière commande)
shopt -s histappend (permettre à plusieurs terminaux d'écrire dans le fichier d'historique )
historique | awk 'COMMENCER {FS="[ \t]+|\\|"} {imprimer $3}' | trier | uniq-c | sort -nr | head (liste les commandes d'historique les plus utilisées)

# Fichier et navigation
cp /home/foo/realllylongname.cpp{,-old}
cd -
rename 's/text_to_find/been_renamed/' *.txt
export CDPATH='/var/log:~' (la variable est utilisée avec le cd intégré.)

# Colorize bash

# activer les couleurs
eval "`dircolors -b`"
# forcer ls à toujours utiliser des indicateurs de couleur et de type
alias ls='ls -hF --color =auto'
# fait fonctionner la commande dir un peu comme sous Windows (format long)
alias dir='ls --color=auto --format=long'
# fait en sorte que grep surligne les résultats en utilisant la couleur
export GREP_OPTIONS='--color=auto'

export LESS_TERMCAP_mb=$'\E[01;31m'
export LESS_TERMCAP_md=$'\E[01; 33m'
export LESS_TERMCAP_me=$'\E[0m'
export LESS_TERMCAP_se=$'\E[0m' # fin de la boîte d'informations
export LESS_TERMCAP_so=$'\E[01;42;30m' # début de la boîte d'informations
export LESS_TERMCAP_ue=$'\E[0m'
export LESS_TERMCAP_us=$'\E[01;36m'

# Raccourcis Bash
    shopt -s cdspell (corrige les fautes de frappe)
    ctrl + _ (annuler)
    ctrl + flèche (avancer d'un mot)
    ctrl + a (déplacer le curseur au début)
    ctrl + e (déplacer curseur à la fin)
    ctrl + k (coupe tout après le curseur)
    ctrl + l (efface l'écran)
    ctrl + q (reprend la commande qui est au premier plan)
    ctrl + s (mettre en pause une longue commande au premier plan)
    ctrl + t (échanger deux caractères)
    ctrl + u (coupe tout ce qui se trouve avant le curseur)
    ctrl + x + ctrl + e ( ouvre la chaîne de commande dans un éditeur afin que vous puissiez la modifier avant son exécution)
    ctrl + x + * (développer glob/étoile)
    ctrl + xx (déplacer vers l'extrémité opposée de la ligne)
    ctrl + y (colle depuis le tampon)
    ctrl + shift + c/v (copier/coller dans le terminal)

# Exécuter des commandes en séquence
&&(exécuter deuxième commande si la première réussit)
 ; (exécuter la deuxième commande quel que soit le succès de la première)

# Redirection des E/S
2>&1 (rediriger stdout et stderr vers un fichier)

# check pour les ports ouverts
echo> /dev/tcp/
/
`` (utilisez des back ticks pour débourser)

# Examiner l'exécutable
quel 
fichier 
commande -V  (vous indique si  est un binaire intégré, ou un alias)