FAQ LinuxConsultez toutes les FAQ

L'interpréteur de ligne de commande (ou "shell") est une interface en mode texte, qui permet à un utilisateur d'interagir avec le noyau afin d'effectuer des opérations diverses : afficher la date, lire un fichier, récupérer des données distantes...
Il comporte des commandes qui lui sont propres (commandes internes), et peut exécuter toutes les commandes disponibles sur le système (commandes externes) pourvu que les ressources soient disponibles : on ne peut pas lancer un programme X* (gedit, firefox...) si X* n'est pas démarré !
Certaines commandes internes de l'interpréteur de commandes sont aussi disponibles en tant que commandes externes : elles portent le même nom, mais n'ont pas obligatoirement les mêmes options, ou les mêmes options ne se comportent pas exactement de la même manière (c'est le cas de time).
Le fonctionnement apparent du shell est simple :
il attend que l'utilisateur appuie sur 'Entrée' après avoir saisi le nom d'une commande ;
il exécute la commande ;
il attend que l'utilisateur appuie sur 'Entrée'...

Les Shells principaux sont :

• Bash (bourne Shell)
• Csh (C shell)
• Ksh (Korn Shell)

Contrairement à Windows, Linux peut être entièrement piloté en ligne de commande, par laquelle on a accès à toute sa puissance et toute sa configuration. L'interface graphique n'est qu'une couche applicative optionnelle, mais non nécessaire pour des serveurs par exemple (qui ne font basiquement que répondre à des requêtes réseau).

Un administrateur système se doit de maîtriser le Shell pour diverses raisons :

• même si certaines distributions ou applications proposent des assistants de configuration graphiques, c'est en modifiant les fichiers de configuration textuels qu'on arrive à paramétrer le plus finement le système ;
• le Shell et son langage sont très puissants, et bien souvent, il est très efficace de réaliser quelques scripts simples pour automatiser certains traitements sur des serveurs ou modifier des configurations de services à la volée ;
• par sécurité, on évite d'installer tout élément non strictement nécessaire sur un serveur (exemple typique : une interface graphique), et son administration à distance se fera la plupart du temps en ssh, qui est un protocole d'accès sécurisé à la console par le réseau ;
• la maîtrise du Shell permet de contrôler le système à 100 % (surveillance complète de l'activité de la machine, démarrage et arrêt d'applications, gestion du multitâche, recherches rapides, etc.) et est donc un moyen très efficace d'administrer une machine

Le Shell est un interpréteur de commande en mode texte (ou console). Il permet de passer des ordres (commandes) au système, et de "dialoguer" avec lui (on parle de shell interactif).
Il est possible de piloter entièrement Linux en ligne de commande : démarrer, suspendre et arrêter des programmes, gérer les services (programmes résidents en mémoire), configurer le système (édition de fichiers texte), gérer les tâches planifiées, le multitâche, etc.

Une des premières choses à apprendre sous Linux est le Shell et ses commandes de base, car cela permet d'avoir une totale maîtrise du système.

Techniquement, le Shell est une boucle infinie en C qui lit ce que l'utilisateur tape au clavier et réagit :

• soit il s'agit d'une commande interne du shell qui est exécutée directement (fonction interne, ou builtin) ;
• soit il lance un programme externe ;
• il doit aussi interpréter les caractères spéciaux (redirection, pipes...).

Il existe plusieurs façons de procéder pour trouver un fichier sous Linux. La méthode la plus utilisée est la commande locate :

$ locate nom_du_fichier

$ find / -name "fichier.txt"

$ find / -name "toto*"

find / -type f -name "le_fichier_a_chercher" 2>/dev/null

1
2
find <repertoire_depart> -type f -exec grep -H "<chaine>" {} ; 
find <repertoire_depart> -type f -exec egrep -H "<regexp>" {} ;

1
2
find <repertoire_depart> -type f | xargs grep -H "<chaine>" 
find <repertoire_depart> -type f | xargs egrep -H "<regexp>"

for f in ./*chaine*; do mv "$f" "${f/chaine/chene}"; done

1
2
shopt -s nullglob globstar 
for f in ./**/*chaine*; do mv "$f" "$(echo "$f" | sed 's/chaine/chene/')"; done

find . -type f -name '*chaine*' -execdir sh -c 'echo mv "$1" "$(echo "$1" | sed "s/chaine/chene/")"' sh {} \;

find . -type f -name "*.conf" | xargs perl -pi.save -e 's/option\=true/option\=false/'

Certes, mv permet de renommer des fichiers. Toutefois, l'outil n'est pas très adapté pour renommer un grand nombre de fichiers. Il est évident que vous pourriez rapidement écrire une boucle for, ou même un script pour arriver à votre fin, mais pourquoi s'embêter alors qu'un outil est là pour ça.
En effet, rename permet de renommer une multitude de fichiers et cela très facilement.

Voici un exemple d'utilisation, permettant de changer l'extension de tous les fichiers de foo à txt du dossier courant :

rename 's/.foo/.txt/' *

rename [ -v ] [ -n ] [ -f ] perlexpr [ fichiers ]

La commande find pour trouver des fichiers propose l'option -size.
Ainsi pour trouver des fichiers de plus de 100 méga-octets, vous pouvez utiliser la commande :

find / -size +100M

• b : pour des blocs de 512 octets ;
• c : pour des octets ;
• w : pour des mots de deux octets ;
• k : pour des kilo-octets (unités de 1 024 octets) ;
• M : pour des méga-octets (unités de 1 048 576 octets) ;
• G : pour des giga-octets (unités de 1 073 741 824 octets) ;
  

find / -size +100M -size -1000M

Lorsqu'on lance un script à travers l'interface graphique, le terminal se ferme à la fin de l'exécution du script, et ce qu'il y eu une erreur ou non.
Vous pouvez empêcher la fermeture du terminal de multiples façons. En voici deux intéressantes :

1
2
echo "Appuyez sur entrée..." 
read

$SHELL

Vous venez de créer un script shell et vous souhaitez vérifier les commandes exécutés par le script (avec leurs options). Pour cela, bash proposé l'option -x. En l'utilisant, bash écrira les commandes lancées par le script.
Par exemple, pour le script suivant :

1
2
3
4
FOLD=/tmp/toto 
touch main.c 
cd /tmp/ 
mkdir ${FOLD}