LPI-101-2-1
Un article de RotomaLUG.
| Frontal web | Wiki accueil | Les forums | La galerie | La liste LUG | La liste INSTALL PARTY |
Site orginal
http://www.gentoo.org/doc/en/articles/lpi-101-fundamentals-p1.xml
Participer à la traduction
Pour participer aux traductions vous devez tout d'abord :
- vous inscrire sur le wiki (Pour créer un compte sur ce wiki, envoyez nous un courrier en suivant ce lien [1] )
- suivre au maximum le petit guide du traducteur
- nous contacter (via l'adresse info@rotomalug) pour l'organisation du travail
Notes de version
Avancement : 100 %
traduction : 100 %
relecture : 100 %
Note de licence : ce document est mis sous licence Creative Commons, pour respecter la licence du document original. (Merci aux juristes de l'association de confirmer que c'est nécessaire et OK).
LPI certification 101 (version 2) préparation à l'examen, Partie 1 - traduction
Avant de commencer
A propos de ce tutoriel
Voici « Fondamentaux Linux », premier d'une série de quatre tutoriels destiné à vous préparer aux examens LPI 101. Dans ce tutoriel, vous suivrez une introduction au bash (le shell linux standard), apprendrez à utiliser les commandes standard Linux telles que ls, cp et mv, aurez une explication sur les inodes, les liens durs et symboliques, et beaucoup plus que ça. A la fin de ce tutoriel vous aurez une sérieuse base sur les fondamentaux Linux et vous serez prêt à apprendre quelques tâches d'administration de base. A la fin de cette série de Tutoriels (8 en tout), vous disposerez des connaissances dont vous avez besoin pour être un administrateur système Linux et serez prêt à obtenir la certification LPIC de niveau 1 du Linux Professional Institute si vous le souhaitez.
Ce tutoriel est idéal pour ceux qui s'initient à Linux, ou pour ceux qui souhaitent revoir ou améliorer leur compréhension des concepts fondamentaux sous Linux comme la copie et le déplacement de fichiers, la création des liens symboliques et durs, et l'utilisation des commandes d'opération sur les chaînes de caractère à travers les tubes ou les redirections. En chemin, nous apporterons nos suggestions, conseils, ou encore nos petits trucs pour rendre ce tutoriel appétissant et pratique, même pour ceux qui ont déjà une bonne expérience sous Linux. Pour les débutants, la plupart de ce qu'ils liront sera tout neuf mais les utilisateurs de Linux plus expérimentés pourront trouver dans ce tutoriel un bon moyen pour compléter leurs compétences Linux.
Ceux qui ont suivi la première version de ce document pour une autre raison que la préparation de la certification LPI n'ont sans doute pas besoin de suivre celle-ci. Par contre, si vous prévoyez de passer les examens, vous devriez envisager de lire cette version révisée.
A propos de l'auteur
Daniel Robbins réside à Albuquerque, nouveau Mexique et est le créateur de la distribution Gentoo Linux une distribution Linux avancée basée sur les ports (au sens BSD). Il écrit également des articles, tutoriels ou conseils pour IBM developerWorks Linux zone et Intel Developer Services et a également contrbué à plusieurs livres comme Samba Unleashed et SuSE Linux Unleashed. Daniel apprécie de passer son temps libre avec sa femme, Mary et sa fille Hadassah. Vous pouviez contacter Daniel à drobbins@gentoo.org.
Note du traducteur : voir également le contenu actuel du Wikipedia sur l'auteur, plus à jour :
Créateur en 2002 de la distribution GNU/Linux Gentoo et fondateur de la fondation Gentoo. Le 26 avril 2004, il quitte le projet pour passer plus de temps avec sa famille. Du 13 juin 2005 au 9 janvier 2006, il rejoint Microsoft, expliquant qu'il souhaitait aider Microsoft à comprendre l'Open Source et les projets communautaires. Avant de quitter gentoo, il a transféré toute propriété intellectuelle de Gentoo vers la fondation Gentoo. Le 9 janvier 2006, il quitte Microsoft.
Introduction au Bash
Le shell
Si vous avez déjà utilisé un système Linux, vous savez que lorsque vous vous connectez, vous êtes accueilli par une invite (prompt) qui ressemble un peu à ceci :
$
L'invite que vous devez voir peut être légèrement différente. par exemple elle peut contenir votre nom d'hôte ou encore votre répertoire de travail. Cependant, sans tenir compte de l'apparence de votre invite, un point est certain : le programme qui affiche cette invite est appelé un « shell » ou interpréteur de commandes et il est très probable que votre shell soit un programme nommé bash.
Êtes vous en train d'utiliser bash ? Vous pouvez le vérifier en tapant :
$ echo $SHELL /bin/bash
Si la ligne précédente vous a retourné une erreur ou quelquechose de différent, vous utilisez peut-être un autre shell que le bash. Dans ce cas, la plus grande partie de ce tutoriel devrait continuer à fonctionner, mais il serait avantageux que vous passiez à bash pour la préparation de l'examen lpi 101.
A propos de bash
Bash, un acronyme de "Bourne-again shell", (ndt : le shell rené - pas comme le prénom - , en référence au bourne shell, le shell natif) est le shell par défaut sur la plupart des systèmes Linux. Le rôle du shell est d'obéir à vos commandes de façon à ce que vous puissiez interagir avec votre système Linux (c'est une interface homme machine en mode texte). Quand vous avez fini d'entrer vos commandes, vous pouvez quitter le shell ou vous déconnecter, à ce point vous retournez à l'invite de connexion.
De la même façon, vous pouvez également vous déconnecter en pressant les touches Control et d simultanément au prompt du bash.
Utiliser "cd"
Comme vous vous en serez probablement rendu compte, observer votre prompt sans rien faire n'est pas la chose la plus intéressante au monde. Alors commençons à utiliser bash pour naviguer dans notre système de fichiers. Au prompt, tapez ceci (sans le $) :
$ cd /
Nous avons seulement dit à bash que nous voulons travailler dans le répertoire /, également connu comme la racine ou le répertoire racine (root) ; tous les répertoires du système forment un arbre ou une arborescence et / (prononcer slash) est considéré comme le point le plus haut (la racine) de cet arbre. cd paramètre le répertoire dans lequel vous êtes en train de travailler, également nommé le répertoire de travail. cd = change (working) directory.
Chemins
Pour connaître votre répertoire de travail actuel, tapez :
$ pwd /
Dans l'exemple précédent, l'argument / passé à cd est appelé un chemin. Il dit à cd où vous souhaitez aller. En particulier, l'argument / est un chemin absolu, ce qui veut dire qu'il spécifie un lieu relatif à la racine de l'arborescence de fichiers.
Chemins absolus
Voici quelques chemins absolus :
/dev /usr /usr/bin /usr/local/bin
Comme vous pouvez le voir, le point commun entre tous les chemins absolus est qu'ils commencent tous par /. Avec le chemin /usr/local/bin, nous disons à cd d'aller dans le répertoire racine, puis d'aller dans usr puis local et bin.
Les chemins absolus sont toujours évalués en partant de /.
Chemins relatifs
L'autre type de chemin est le chemin relatif. cd et les autres commandes interprètent toujours ces chemins par rapport au répertoire courant (répertoire de travail). Les chemins relatifs ne commencent jamais par un /. Donc, si vous êtes dans /usr :
$ cd /usr
Alors vous pouvez utiliser un chemin relatif pour vous placer dans le répertoire /usr/local/bin :
$ cd local/bin $ pwd /usr/local/bin
Utiliser ..
Les chemins relatifs peuvent également contenir un ou plusieurs répertoires .. (dites point-point pas deux points ou coin-coin) . Le répertoire .. est un répertoire spécial qui pointe sur le répertoire parent (celui du niveau du dessus dans l'arborescence). Donc, à partir de l'exemple précédent :
$ pwd /usr/local/bin $ cd .. $ pwd /usr/local
Comme vous pouvez le voir , notre répertoire courant est désormais /usr/local. Nous avons été capable de "remonter" d'un répertoire, relativement au répertoire où nous nous trouvions.
En outre, nous pouvons également ajouter .. à un chemin relatif existant, ce qui nous permet d'aller dans un répertoire qui est au même niveau de l'arborescence que celui où nous nous trouvons, par exemple :
$ pwd /usr/local $ cd ../share $ pwd /usr/share
Exemples de chemins relatifs
Les chemins relatifs peuvent devenir assez complexes. Voici quelques exemples, dont aucun ne présente le répertoire de destination. Essayez de trouver le répertoire d'arrivée après avoir tapé ces commandes :
$ cd /bin $ cd ../usr/share/zoneinfo $ cd /usr/X11R6/bin $ cd ../lib/X11 $ cd /usr/bin $ cd ../bin/../bin
Maintenant essayez les et regardez si vous aviez visé juste ;)
Comprendre "."
Avant que nous ayons fini notre tour sur cd, il faut que je mentionne encore quelques points. Tout d'abord, il y a un autre répertoire spécial, appelé ., qui signifie "le répertoire courant". Ce répertoire n'est pas utilisé avec la commande cd, mais est régulièrement utilisé pour exécuter des programmes dans les répertoire courant, comme suit :
$ ./myprog
Dans l'exemple précédent, le programme exécutable myprog résidant dans le répertoire courant sera exécuté.
cd et le répertoire personnel
Si nous souhaitions aller dans notre répertoire personnel, nous pourrions taper :
$ cd
Sans argument, cd vous replace dans votre répertoire personnel, qui est /root pour le superutilisateur (l'administrateur) et typiquement /home/nomdutilisateur pour un utilisateur courant. Mais comment spécifier un fichier dans notre répertoire personnel ? Par exemple nous pourrions vouloir passer un fichier en argument à la commande myprog. Si ce fichier se situe dans notre répertoire personnel, nous pouvons taper :
$ ./myprog /home/drobbins/myfile.txt
Cependant, utiliser un chemin absolu comme ça n'est pas toujours confortable. Heureusement, nous pouvons utiliser le caractère ~ (tilde) pour faire la même chose :
$ ./myprog ~/myfile.txt
Les répertoires personnels des autres utilisateurs
Bash comprendra un ~ seul comme pointant vers votre répertoire personnel, mais vous pouvez également utiliser le tilde pour pointer vers le répertoire personnel d'autres utilisateurs. par exemple, si vous souhaitez vous référer à un fichier nommé fredsfile.txt dans le répertoire personnel de Fred, nous pourrions taper :
$ ./myprog ~fred/fredsfile.txt
Utilisation des commandes Linux
Introduction à ls
Regardons maintenant brièvement la commande ls. Il est très probable que vous soyez familier avec cette commande qui, par elle même, retourne le contenu du répertoire courant :
$ cd /usr $ ls X11R6 doc i686-pc-linux-gnu lib man sbin ssl bin gentoo-x86 include libexec portage share tmp distfiles i686-linux info local portage.old src
En spécifiant l'option -a, on peut voir tous les fichiers du répertoire, y compris les fichiers cachés : ceux qui commencent avec .. Comme vous pouvez le voir dans l'exemple suivant, ls -a montre les liens spéciaux vers les répertoires . et .. :
$ ls -a . bin gentoo-x86 include libexec portage share tmp .. distfiles i686-linux info local portage.old src X11R6 doc i686-pc-linux-gnu lib man sbin ssl
Listes de répertoires longs
Vous pouvez aussi spécifier un ou plusieurs fichiers ou répertoires à la commande ls. Si vous spécifiez un fichier, ls n'affiche que celui-ci. Si vous spécifiez un répertoire, ls vous affichera le contenu de celui-ci. L'option -l est très pratique si vous avez besoin de voir les permissions, le propriétaire, l'heure de modification, et les informations sur la taille dans le répertoire que vous listez.
Dans l'exemple suivant, nous utilisons l'option -l pour afficher mon répertoire /usr
$ ls -l /usr drwxr-xr-x 7 root root 168 Nov 24 14:02 X11R6 drwxr-xr-x 2 root root 14576 Dec 27 08:56 bin drwxr-xr-x 2 root root 8856 Dec 26 12:47 distfiles lrwxrwxrwx 1 root root 9 Dec 22 20:57 doc -> share/doc drwxr-xr-x 62 root root 1856 Dec 27 15:54 gentoo-x86 drwxr-xr-x 4 root root 152 Dec 12 23:10 i686-linux drwxr-xr-x 4 root root 96 Nov 24 13:17 i686-pc-linux-gnu drwxr-xr-x 54 root root 5992 Dec 24 22:30 include lrwxrwxrwx 1 root root 10 Dec 22 20:57 info -> share/info drwxr-xr-x 28 root root 13552 Dec 26 00:31 lib drwxr-xr-x 3 root root 72 Nov 25 00:34 libexec drwxr-xr-x 8 root root 240 Dec 22 20:57 local lrwxrwxrwx 1 root root 9 Dec 22 20:57 man -> share/man lrwxrwxrwx 1 root root 11 Dec 8 07:59 portage -> gentoo-x86/ drwxr-xr-x 60 root root 1864 Dec 8 07:55 portage.old drwxr-xr-x 3 root root 3096 Dec 22 20:57 sbin drwxr-xr-x 46 root root 1144 Dec 24 15:32 share drwxr-xr-x 8 root root 328 Dec 26 00:07 src drwxr-xr-x 6 root root 176 Nov 24 14:25 ssl lrwxrwxrwx 1 root root 10 Dec 22 20:57 tmp -> ../var/tmp
La première colonne affiche les informations sur les permissions de chaque objet de la liste. J'expliquerai bientôt comment interpréter ces informations. La colonne suivante liste le nombre de liens à chaque objet du système de fichier, mais nous y reviendrons plus tard. La troisième et quatrième colonne listent le propriétaire et le groupe. La cinquième colonne liste la taille de l'objet. La sixième colonne est la "dernière modification" ou "mtime" de l'objet. Enfin la dernière colonne est le nom de l'objet. Si ce fichier est un lien symbolique, vous verrez à la suite un -> et le chemin vers lequel pointe ce lien symbolique.
Examiner les répertoires
Parfois, vous souhaitez observer les répertoires plutôt que leur contenu. Pour cela, vous pouvez spécifier l'option -d qui indiquera à ls d'observer les répertoires plutôt que leur contenu :
$ ls -dl /usr /usr/bin /usr/X11R6/bin ../share drwxr-xr-x 4 root root 96 Dec 18 18:17 ../share drwxr-xr-x 17 root root 576 Dec 24 09:03 /usr drwxr-xr-x 2 root root 3192 Dec 26 12:52 /usr/X11R6/bin drwxr-xr-x 2 root root 14576 Dec 27 08:56 /usr/bin
Listes récursives et inodes
Vous pouvez donc utilisez -d pour observer un répertoire, mais également -R pour faire le contraire : c'est à dire pas simplement lister le contenu d'un répertoire, mais également, de façon récursive, tous les fichiers et répertoires à l'intérieur de celui-ci ! Nous ne présenterons pas d'exemple de cette commande (car généralement assez volumineux), mais vous pouvez essayer quelques ls -R et ls -lR pour comprendre leur fonctionnement.
Enfin, l'option -i peut être utilisée pour afficher l'inode des objets du système de fichier dans la liste :
$ ls -i /usr
1409 X11R6 314258 i686-linux 43090 libexec 13394 sbin
1417 bin 1513 i686-pc-linux-gnu 5120 local 13408 share
8316 distfiles 1517 include 776 man 23779 src
43 doc 1386 info 93892 portage 36737 ssl
70744 gentoo-x86 1585 lib 5132 portage.old 784 tmp
Comprendre les inodes
Chaque objet du système de fichier se voit attribuer un indice unique, appelé l'inode. Cela peut sembler trivial, mais la compréhension des inodes est essentielle pour comprendre beaucoup d'opérations du système de fichiers. Par exemple, considérons les liens . et .. qui apparaissent dans chaque répertoire. Pour bien comprendre ce qu'est en fait le répertoire .., nous allons d'abord regarder l'inode du répertoire /usr/local :
$ ls -id /usr/local 5120 /usr/local
Le répertoire /usr/local a pour inode 5120. Regardons maintenant l'inode du répertoire /usr/local/bin/.. :
$ ls -id /usr/local/bin/.. 5120 /usr/local/bin/..
Comme vous pouvez le voir, /usr/local/bin/.. a le même inode que /usr/local/ ! Voilà une révélation surprenante. Nous avions précédemment considéré /usr/local comme un répertoire. Maintenant, nous découvrons que l'inode 5120 est en fait un répertoire, et nous avons trouvé deux entrées à ce répertoire (appelés liens) qui pointent vers cet inode. Aussi bien /usr/local que /usr/local/bin/.. sont liés à l'inode 5120. Bien que l'inode 5120 n'existe qu'à un seul endroit sur le disque, de nombreux liens pointent vers lui. L'inode 5120 est la vrai entrée sur le disque. En fait, nous pouvons voir le nombre total de fois où l'inode 5120 est référencé en utilisant la commande ls -dl :
$ ls -dl /usr/local drwxr-xr-x 8 root root 240 Dec 22 20:57 /usr/local
Si nous regardons la seconde colonne, nous pouvons voir que le répertoire /usr/local (inode 5120) est référencé 8 fois. sur mon système, voici les différents chemins qui font référence à cet inode :
/usr/local /usr/local/. /usr/local/bin/.. /usr/local/games/.. /usr/local/lib/.. /usr/local/sbin/.. /usr/local/share/.. /usr/local/src/..
mkdir
Regardons rapidement la commande mkdir, qui peut être utilisée pour créer de nouveau répertoires. L'exemple suivant crée trois nouveaux répertoires, tic, tac et toe, dans /tmp :
$ cd /tmp $ mkdir tic tac toe
Par défaut, la commande mkdir ne crée pas les répertoires parents pour vous; tout le chemin jusqu'à l'avant dernier élément doit exister. Donc, si vous voulez créer le répertoire won/der/ful, vous devrez utiliser trois fois la commande mkdir :
$ mkdir won/der/ful mkdir: Ne peut créer le répertoire `won/der/ful': Aucun fichier ou répertoire de ce type $ mkdir won $ mkdir won/der $ mkdir won/der/ful
Cependant, mkdir dispose de l'option -p qui permet de créer les répertoires parents manquants, comme vous pouvez le voir :
$ mkdir -p easy/as/pie
Vraiment très pratique. Pour en apprendre plus sur la commande mkdir, tapez man mkdir pour lire la page de manuel. Ceci est valable pour presque toutes les commandes présentées ici (par exemple man ls), sauf pour cd, qui est une commande interne au bash.
touch
Nous allons maintenant regarder les commandes cp et mv, qui permettent de copier, renommer et déplacer des fichiers et répertoires. Pour commencer, nous utiliserons la commande touch pour créer un fichier dans /tmp :
$ cd /tmp $ touch copyme
La commande touch met à jour le "mtime" d'un fichier existant (souvenez vous la sixième colonne de ls -l). Si le fichier n'existe pas, alors un nouveau fichier vide est créé. Vous devriez maintenant avoir un fichier /tmp/copyme de taille nulle.
echo
Maintenant que le fichier existe, ajoutons lui quelques données. Nous pouvons faire cela avec la commande echo, qui prend ses arguments et les affiche sur la sortie standard. Tout d'abord, la commande echo par elle même :
$ echo "firstfile" firstfile
Et la même commande avec une redirection de sa sortie :
$ echo "firstfile" > copyme
Le symbole supérieur indique au shell qu'il faut écrire la sortie de la commande echo dans le fichier copyme. Le fichier sera créé s'il n'existe pas, et sera écrasé s'il existe. En tapant ls -l, nous pouvons voir que le fichier copyme fait 10 bytes, maintenant qu'il contient le mot firstfile et celui de nouvelle ligne :
$ ls -l copyme -rw-r--r-- 1 root root 10 Dec 28 14:13 copyme
cat et cp
Pour afficher le contenu de ce fichier sur le terminal, nous pouvons utiliser la commande cat :
$ cat copyme firstfile
Nous pouvons alors utiliser simplement la commande cp pour créer un fichier copiedme à partir du fichier original copyme :
$ cp copyme copiedme
Nous pouvons nous assurer qu'il s'agit bien de deux fichiers différents en observant leurs inodes :
$ ls -i copyme copiedme 648284 copiedme 650704 copyme
mv
Utilisons la commande mv pour renommer "copiedme" en "movedme". L'inode restera le même ; cependant, le nom de fichier qui pointe vers cet inode changera.
$ mv copiedme movedme $ ls -i movedme 648284 movedme
L'inode du fichier déplacé restera le même tant que le fichier de destination restera sur le même système de fichiers que le fichier source. Nous regarderons de plus près le système de fichiers dans la partie 3 de ce tutoriel. Tant que nous parlons de mv, voyons une autre façon d'utiliser cette commande. En plus de renommer des fichiers, la commande mv permet également de déplacer un ou plusieurs fichiers vers une autre destination dans la hiérarchie des répertoires. Par exemple, pour déplacer /var/tmp/myfile.txt vers /home/drobbins (qui est mon répertoire personnel), je peux taper :
$ mv /var/tmp/myfile.txt /home/drobbins
Après avoir tapé cette commande, myfile.txt sera déplacé vers /home/drobbins/myfile.txt. Et si /home/drobbins est sur un système de fichier différent de /var/tmp, la commande mv déplacera le fichier copié myfile.txt vers le nouveau système de fichier, en l'effaçant de l'ancien système de fichier. Comme vous pouvez le deviner, lorsque myfile.txt est déplacé entre les systèmes de fichiers, le fichier myfile.txt au nouvel emplacement disposera d'un nouvel inode. Ceci vient du fait que chaque système de fichier doit avoir son propre jeu de numéros d'inodes.
Nous pouvons également utiliser la commande mv pour déplacer plusieurs fichiers vers une même destination. Par exemple, pour déplacer myfile1.txt et myarticle3.txt vers /home/drobbins, je peux taper :
$ mv /var/tmp/myfile1.txt /var/tmp/myarticle3.txt /home/drobbins
Création de liens et suppression de fichier
Liens durs
Nous avons mentionné le terme lien pour parler de la relation entre des entrées de répertoires (les "noms" que nous tapons) et les inodes (les nombres dans l'index du système de fichiers dont on peut généralement ne pas tenir compte). Il y a en fait deux types de liens sur Linux. Ceux dont nous avons parlé sont les liens durs. A un inode correspond un certain nombre de liens durs, et cet inode existe sur le système de fichiers tant que tous les liens durs n'ont pas disparus. Lorsque le dernier lien disparait et qu'aucun programme laisse le fichier ouvert, Linux efface ce fichier automatiquement. De nouveaux liens durs peuvent être créés avec la commande ln :
$ cd /tmp $ touch firstlink $ ln firstlink secondlink $ ls -i firstlink secondlink 15782 firstlink 15782 secondlink
Comme vous pouvez le voir, les liens durs fonctionnent au niveau de l'inode pour un fichier donné. Sur les systèmes Linux, les liens durs ont certaines limitations. Par exemple, vous pouvez faire des liens durs vers de fichiers, mais pas vers des répertoires. C'est vrai, cependant . et .. sont des liens durs vers des répertoires créés par le système, et vous (même en tant qu'utilisateur root) n'avez pas le droit de créer les vôtres. La seconde limitation des liens durs est qu'ils ne peuvent pas "dépasser" votre système de fichiers. C'est à dire que vous ne pouvez pas créer un lien de /usr/bin/bash sur /bin/bash si vos répertoires / et /usr sont sur des systèmes de fichiers différents.
Liens symboliques
En pratique, les liens symboliques sont plus utilisés que les liens durs. Les liens symboliques sont des fichiers spéciaux pour lesquels le lien vers un fichier est fait d'après le nom, et non directement à partir de l'inode. Les liens symboliques ne permettent pas qu'un fichier ne soit effacé ; si la cible disparaît, alors le lien symbolique sera inutilisable ou cassé.
Un lien symbolique est créé en utilisant l'option -s avec ln :
$ ln -s secondlink thirdlink $ ls -l firstlink secondlink thirdlink -rw-rw-r-- 2 agriffis agriffis 0 Dec 31 19:08 firstlink -rw-rw-r-- 2 agriffis agriffis 0 Dec 31 19:08 secondlink lrwxrwxrwx 1 agriffis agriffis 10 Dec 31 19:39 thirdlink -> secondlink
Les liens symboliques peuvent être reconnus, avec la commande ls -l, de trois façon. Un, la première colonne contient le caractère l qui signifie qu'il s'agit d'un lien symbolique. Deux, la taille du lien symbolique correspond au nombre de caractères de la cible (secondlink dans ce cas). Trois, la dernière colonne affiche le nom de la cible du lien précédé par ->.
Les liens symboliques en détails
Les liens symboliques sont généralement plus flexibles que les liens durs. Vous pouvez créer un lien symbolique vers n'importe quel type d'objet du système de fichier, y compris les répertoires. Et parce que l'implémentation des liens symboliques est basée sur les chemins (et non les inodes), il est parfaitement possible de créer un lien symbolique qui pointe vers un objet d'un système de fichiers qui ne soit pas le même physiquement. Cependant, cela peut rendre les liens symboliques difficiles à comprendre.
Considérons une situation où nous voulons créer un lien dans /tmp qui pointe vers /usr/local/bin. Nous pourrions taper :
$ ln -s /usr/local/bin bin1 $ ls -l bin1 lrwxrwxrwx 1 root root 14 Jan 1 15:42 bin1 -> /usr/local/bin
Ou encore :
$ ln -s ../usr/local/bin bin2 $ ls -l bin2 lrwxrwxrwx 1 root root 16 Jan 1 15:43 bin2 -> ../usr/local/bin
Comme vous pouvez le voir, les deux liens symboliques pointent vers le même répertoire. Cependant, si votre second lien symbolique venait à être déplacé vers un autre répertoire, il serait cassé à cause du chemin relatif :
$ ls -l bin2 lrwxrwxrwx 1 root root 16 Jan 1 15:43 bin2 -> ../usr/local/bin $ mkdir mynewdir $ mv bin2 mynewdir $ cd mynewdir $ cd bin2 bash: cd: bin2: Aucun fichier ou répertoire de ce type
Parce que le répertoire /tmp/usr/local/bin n'existe pas, vous ne pouvez plus changer de répertoire dans bin2 ; en d'autres mots, bin2 est maintenant cassé.
C'est pour cela qu'il est parfois mieux de ne pas créer des liens symboliques en utilisant des chemins relatifs. Cependant, il y a de nombreux cas où les liens symboliques relatifs sont pratiques. Prenons l'exemple où vous créez un nom alternatif pour un programme dans /usr/bin :
# ls -l /usr/bin/keychain -rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/bin/keychain
En tant qu'utilisateur root, vous souhaitez peut être créer un nom alternatif pour "keychain", par exemple "kc". Dans ce cas, nous avons les droits root, comme l'indique le prompt du bash qui est devenu "#". Vous avez besoin des droits root car un utilisateur normal ne peut pas créer de fichier dans /usr/bin. En tant que root, vous pouvez créer un nom alternatif à keychain de la façon suivante :
# cd /usr/bin # ln -s /usr/bin/keychain kc # ls -l keychain -rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/bin/keychain # ls -l kc lrwxrwxrwx 1 root root 17 Mar 27 17:44 kc -> /usr/bin/keychain
Dans cet exemple, nous avons créé un lien symbolique appelé kc qui pointe vers le fichier /usr/bin/keychain.
Bien que cette solution fonctionne, elle peut poser problème si nous décidons de déplacer les deux fichiers /usr/bin/keychain et /usr/bin/kc vers /usr/local/bin :
# mv /usr/bin/keychain /usr/bin/kc /usr/local/bin # ls -l /usr/local/bin/keychain -rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/local/bin/keychain # ls -l /usr/local/bin/kc lrwxrwxrwx 1 root root 17 Mar 27 17:44 kc -> /usr/bin/keychain
Parce que nous avons utilisé de chemin absolu dans notre lien symbolique, notre lien kc pointe toujours vers /usr/bin/keychain, qui n'existe plus puisqu'il a été déplacé de /usr/bin/keychain vers /usr/local/bin.
En d'autres termes, le lien kc est cassé (sans jeu de mot). Les deux types de chemins, relatif et absolus, ont leurs propres avantages, que vous devrez choisir suivant vos applications. Très souvent, les deux fonctionnent bien. L'exemple suivant aurait fonctionné après le déplacement des fichiers :
# cd /usr/bin # ln -s keychain kc # ls -l kc lrwxrwxrwx 1 root root 8 Jan 5 12:40 kc -> keychain # mv keychain kc /usr/local/bin # ls -l /usr/local/bin/keychain -rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/local/bin/keychain # ls -l /usr/local/bin/kc lrwxrwxrwx 1 root root 17 Mar 27 17:44 kc -> keychain
Nous pouvons maintenant lancer le programme keychain en tapant /usr/local/bin/kc. /usr/local/bin/kc pointe vers le programme keychain, dans le même répertoire que kc.
rm
Maintenant que nous savons utiliser cp, mv et ln, il est temps d'apprendre comment supprimer des objets du système de fichiers. Normalement, c'est ce que fait la commande rm. Pour supprimer des fichiers, il faut simplement les spécifier sur la ligne de commande :
$ cd /tmp $ touch file1 file2 $ ls -l file1 file2 -rw-r--r-- 1 root root 0 Jan 1 16:41 file1 -rw-r--r-- 1 root root 0 Jan 1 16:41 file2 $ rm file1 file2 $ ls -l file1 file2 ls: file1: Aucun fichier ou répertoire de ce type ls: file2: Aucun fichier ou répertoire de ce type
Remarquons que sous Linux, une fois qu'un fichier est effacé, c'est définitif. C'est pour cette raison que beaucoup de jeunes administrateurs système utilisent l'option -i lorsqu'ils suppriment des fichiers. L'option -i indique à rm d'effacer les fichiers en mode interactif, et de demander avant d'effacer les fichiers. Par exemple :
$ rm -i file1 file2 rm: détruire fichier régulier vide `file1'? y rm: détruire fichier régulier vide `file2'? y
Dans l'exemple ci-dessus, la commande rm demande confirmation avant d'effacer réellement le fichier. Afin de les supprimer, j'ai dû taper "y" et Entrée deux fois. Si j'avais tapé "n", le fichier n'aurait pas été supprimé. Et si j'avais fait une grosse erreur, j'aurais pu taper Control-C pour annuler complètement le rm -i. Tout ce qui est fait avant peut potentiellement causer des dégâts sur mon système.
Si vous êtes déjà habitué à la commande rm, il peut être pratique d'ajouter la ligne suivante dans votre fichier ~.bashrc avec votre éditeur de texte favori, puis vous déconnecter et vous reconnecter (ou encore taper : $ source ~/.bashrc). Ensuite, à chaque fois que vous taperez rm, le bash convertira automatiquement votre commande en rm -i. De cette façon, rm fonctionnera toujours en mode interactif :
alias rm="rm -i"
rmdir
Pour supprimer des répertoires, vous avez deux options. Vous pouvez supprimer tous les objets à l'intérieur de ce répertoire, et ensuite utiliser la commande rmdir pour supprimer les répertoire lui même :
$ mkdir mydir $ touch mydir/file1 $ rm mydir/file1 $ rmdir mydir
Tous les utilisateurs avancés ou administrateurs préfèrent utiliser la commande rm -rf, plus pratique comme nous allons le voir.
Le meilleur moyen de supprimer un répertoire est d'utiliser les options récursive et forcée de la commande rm, ce qui permet à la commande rm de supprimer le répertoire choisi, ainsi que les objets qu'il contient :
$ rm -rf mydir
Géneralement, rm -rf est utilisé pour supprimer une arborescence de répertoires. Soyez très prudent lors de l'utilisation de la commande rm -rf dont la puissance peut permettre le meilleur comme le pire :-)
Utiliser les caractères spéciaux ou jockers
Introduction aux caractères spéciaux ou jockers
Dans votre utilisation quotidienne de Linux, il y a de nombreuses occasions où vous avez besoin d'effectuer une même opération (par exemple rm), sur plusieurs fichiers à la fois. Dans ces situations, il est souvent fastidieux de taper tous les noms de fichier sur la ligne de commande :
$ rm file1 file2 file3 file4 file5 file6 file7 file8
Pour résoudre ce problème, vous pouvez tirer parti des jockers de votre shell Linux. Cette fonctionnalité vous permet de sélectionner plusieurs fichiers à la fois en utilisant des caractères spéciaux. Bash et d'autres interpréteurs de commande Linux interpréteront ces caractères en cherchant sur le disque tous les fichiers qui correspondent. Ainsi, si vous avez des fichiers file1 à file8 dans le répertoire de travail, vous pouvez les effacer en tapant :
$ rm file[1-8]
Ou si vous voulez simplement effacer tous les fichiers dont le nom commence par file, ou est file, vous pouvez taper :
$ rm file*
Le caractère spécial * correspond à une chaîne de caractère ayant une taille indéfinie (de 0 caractères à ... beaucoup). Les caractères peuvent être n'importe quoi. Le caractère spécial ? correspond à 1 caractère. On peut dire qu'il endosse le même rôle que *, sauf qu'ici on connait la longueur de la chaîne de caractères : 1.
illustration:
$ touch file1 file2 file3 file10 file $ ls file file1 file10 file2 file3 $ rm file? $ ls file file10 $ touch file1 file2 file3 file10 file $ rm file* $ ls $
Les jockers sont également appelés wildcards en anglais.
Bien sûr, les caractères spéciaux peuvent être utilisés pour bien d'autres choses que la suppression de fichiers, comme nous allons le voir.
Comprendre les non correspondances
Si vous voulez lister tous les objets du système de fichier dans /etc qui commencent par g ou qui s'appellent g, vous pouvez taper :
$ ls -d /etc/g* /etc/gconf /etc/ggi /etc/gimp /etc/gnome /etc/gnome-vfs-mime-magic /etc/gpm /etc/group /etc/group-
Que se passe t-il maintenant si vous spécifiez un motif qui n'a aucune correspondance ? Dans l'exemple suivant, nous essayons de lister tous les fichiers dans /usr/bin qui commencent par asdf et qui finissent par jkl, y compris éventuellement le fichier asdfjkl :
ls -d /usr/bin/asdf*jkl ls: /usr/bin/asdf*jkl: Aucun fichier ou répertoire de ce type
Voici ce qu'il arrive. Normalement, lorsque vous indiquez un motif, celui-ci correspond à un ou plusieurs fichiers, et le bash remplace le motif avec un liste d'objets correspondants séparés par des espaces. Cependant, lorsque le motif n'est jamais rencontré, le bash laisse les arguments, caractères spéciaux ou autres, tels quels. Ainsi, ls ne peut pas trouver les fichier /usr/bin/asdf*jkl et nous retourne une erreur. La règle ici est que les jockers ne sont développés que s'ils trouvent une correspondance avec un objet. Sinon, ils restent tels quels et sont directement passés au programme que vous appelez.
Syntaxe des caractères spéciaux : * et ?
Maintenant que nous avons vu comment les jockers fonctionnent, nous devrions regarder la syntaxe des caractères spéciaux. Vous pouvez utiliser les caractères spéciaux pour l'expansion des caractères de remplacement :
* correspondra à zero ou plus de caractères. Ce qui signifie "n'importe quoi peut aller ici, y compris rien". Exemples :
- /etc/g* correspond à tous les fichiers dans /etc qui commencent par g, ou au fichier nommé g.
- /tmp/my*1 correspond à tous les fichiers dans /tmp qui commencent par my et finissent par 1, y compris le fichier my1.
? correspond à n'importe quel caractère unique. Exemple :
- myfile? correspond à tous les fichiers dont le nom est composé de myfile suivi par un seul caractère
- /tmp/notes?txt correspondrait aussi bien à /tmp/notes.txt qu'à /tmp/notes_txt s'ils existent.
Syntaxe des caractères spéciaux : []
Ce caractère spécial est comme ?, mais il autorise plus d'options. Pour utiliser ce caractère spécial, placez n'importe quels caractères que vous souhaitez trouver entre les []. L'expression qui en résultera correspondra à une unique occurrence de n'importe lequel de ces caractères. Vous pouvez également utiliser - pour indiquer un intervalle, ou même combiner des intervalles. Par exemple :
- myfile[12] correspondra à myfile1 et myfile2. Le caractère spécial sera remplacé dès lors qu'au moins un de ces fichier existe dans le répertoire courant.
- [Cc]hange[Ll]og correspondra à Changelog, ChangeLog, changeLog, et changelog. Comme vous pouvez le voir, l'utilisation des crochets peut être utile pour trouver les changements majuscule/minuscule.
- ls /etc/[0-9]* listera tous le fichiers dans /etc qui commencent par un nombre
- ls /tmp/[A-Za-z]* listera tous le fichiers dans /tmp qui commencent par une lettre majuscule ou minuscule.
La construction [!] est similaire à [], à ceci près qu'au lieu de chercher les correspondance avec les caractères entre les crochets, il cherchera n'importe quels caractères, tant qu'il n'est pas listé entre le [! et le ]. Par exemple :
- rm myfile[!9] supprimera tous les fichiers nommés myfile suivis d'un caractère, sauf myfile9.
Avertissement sur les caractères spéciaux
Voici les points auxquels il faut faire attention lorsque vous utilisez les caractères spéciaux. Etant donné que le bash interprète les caractères spéciaux (?, [, ], et *) de façon spécifique, vous devez faire particulièrement attention lorsque vous les utilisez en argument d'une ligne de commande. Par exemple, si vous voulez créer un fichier qui contient la chaine [fo]*, la ligne de commande suivante ne fera pas ce que vous souhaitez :
$ echo [fo]* > /tmp/mynewfile.txt
Si le motif [fo]* correspond à des fichiers dans votre répertoire courant, vous trouverez alors leurs noms dans le fichier /tmp/mynewfile.txt plutôt que [fo]* comme vous pouviez l'espérer. Quelle solution ? Une approche consiste à entourer vos caractères par de simples quotes, ce qui indique au bash d'ignorer les caractères spéciaux :
$ echo '[fo]*' > /tmp/mynewfile.txt
Avec cette approche, le nouveau fichier contiendra bien [fo]* comme souhaité. Une autre méthode est d'utiliser un backslash pour indiquer au bash que [, ], et * doivent être traités litérallement et non comme des caractères spéciaux :
$ echo \[fo\]\* > /tmp/mynewfile.txt
Les deux approches (simple quote et backslash) ont le même effet. Comme nous parlons des extensions liées au backslash, c'est le bon moment pour dire, par rapport au \ litéral, vous pouvez soit le placer entre des quotes simples, soit taper \\ (qui sera étendu en \).
Note : les doubles quotes fonctionnent de manière similaire aux simples quotes, mais en n'autorisant le bash qu'à certaines expansions. Cependant, les simples quotes sont vos meilleurs amis si vous êtes réellement intéressé pour passer littérallement du texte à une commande. Pour plus d'informations sur l'expansion des caractères spéciaux, tapez man 7 glob. Pour plus d'informations sur les quotes dans bash, tapez man 8 glob et lisez la section intitulée QUOTING. Si vous envisagez de passez l'exament LPI, considérez cela comme des devoirs :)
Résumé et ressources
Résumé
Félicitations, vous avez atteint la fin de ce tutoriel sur les bases de l'administration Linux ! J'espère qu'il vous a aidé à asseoir vos connaissances sur Linux. Les éléments que vous avez appris ici, incluant des bases de bash, les commandes de base Linux et les jockers ont mis en place la base nécessaire pour suivre notre prochain tutoriel sur l'administration de base, dans lequel nous verrons des thèmes comme les expressions rationnelles, la propriété et les permissions sur les fichiers, la gestion des comptes utilisateurs, etc.
En continuant cette série de tutoriels, vous serez bientôt prêt à passer votre certification LPUC de niveau 1 du LPI. A propos de la certification LPIC si cela vous intéresse, nous vous recommandons de travailler les ressources suivantes que nous avons attentivement sélectionnées pour améliorer ce que nous venons de voir.
Ressources
Dans la série d'articles « Bash par l'exemple » sur developerWorks, Daniel vous montre comment écrire vos propres scripts bash. Cette série (particulièrement les parties 1 et 2) sont une bonne préparation à l'examen LPIC de niveau 1 :
- Bash by example, Part 1: Fundamental programming in the Bourne-again shell
- Bash by example, Part 2: More bash programming fundamentals
- Bash by example, Part 3: Exploring the ebuild system
Si vous êtes un utilisateur Linux débutant ou moyen, vous devriez également consulter la FAQ Technique pour les utilisateurs Linux, une liste de 50 pages de questions les plus fréquemment posées, avec des réponses détaillées. La FAQ est au format PDF.
Si vous n'êtes pas familiarisé avec l'éditeur vi, consultez le tutotiel developerWorks d'introduction à vi. Ce tutoriel vous donne une rapide introduction à ce puissant éditeur de texte. Considérez que vous devez le lire si vous ne savez pas utiliser vi.
