Vous êtes sur la page 1sur 21

IUT INFORMATIQUE DE MAUBEUGE

MEMENTO ASR3

Ce mémento est fait pour vous fournir un minimum de bases nécessaires à la mise en oeuvre de
scripts sous Linux , il vous fournit les principes élémentaires nécessaires en SHELL. La distribution
Linux utilisée dans le département Informatique de Maubeuge est la Debian ETCH2. L'ouverture
d'une session sous Etch se fait de façon classique à l'aide du login et mot de passe qui vous ont été
fournis en début d'année. L'interface graphique sous Linux, n'est pas indispensable au fonctionnement
de Linux, vous vous en rendrez vite compte, nombreuses sont les choses que l'on peut faire en mode
dit «console ». On dispose ainsi de 6 consoles textes par défaut (tty1 à tty6 ), on bascule entre elles à
l'aide de la séquence de touches suivante: Alt+Ctrl+F1 à 6. Pour revenir en mode graphique c'est très
simple: Alt+Ctrl+F7. On peut également ouvrir un terminal en mode graphique qui vous permettra de
taper vos commandes

Table des matières


I.L'Invite de commande.............................................................................................................................1
II.Les paramètres passés à une commande...............................................................................................1
III.Retrouver les commandes sous Linux..................................................................................................2
IV.L'arborescence Linux...........................................................................................................................2
V.Les fichiers ............................................................................................................................................3
VI.La gestion des droits sous Linux..........................................................................................................4
VII.Les variables.......................................................................................................................................5
VIII.Les commandes en shell...................................................................................................................6
IX.Utilisation du man................................................................................................................................8
X.Les Processus.........................................................................................................................................9
XI.l'éditeur VIM en mode console..........................................................................................................14
XII.Ecrire son premier script:(test,boucles..)..........................................................................................16

I. L'Invite de commande
En mode console vous vous retrouvez devant ce que l'on appelle « une invite de
commande »,c'est un message qui vous invite à rentrer une commande en vous donnant par la même
occasion une foule d'informations. Cette invite s'affiche avant chaque commande que vous tapez,
ex: igi1@s25pc1:~$. Les commandes sous linux sont interprétées par le « SHELL », ils en existent
plusieurs (bash, sh,csh...) ayant à quelques différences près les mêmes fonctionnalités. Si on
décortique l'invite de commande, on s'aperçoit que le premier mot est le login utilisateur et le
deuxième le nom de l'ordinateur, les deux sont reliés par le caractère @, on pourrait traduire par igi1
sur l'ordinateur s25pc1

Deux signes suivent ensuite le « ~ » et le « $ », le premier signifie signifie que nous sommes
dans notre répertoire personnel, le deuxième que nous sommes un utilisateur dit « normal », en effet
on peut être le super utilisateur que l'on nomme « root » sous linux et auquel cas le signe « ~ » sera
suivi du signe « # » ex: s25pc1:~# (le nom d'utilisateur disparaît, il n'y a qu'un seul root!).

II. Les paramètres passés à une commande


On peut passer à une commande ce que l'on appelle des paramètres. Les paramètres sont des
options que l'on écrit à la suite de la commande. La commande et les paramètres sont séparés par un
espace. Ainsi la commande « ls » seule vous donne le contenu d'un répertoire, si nous lui passons le
paramètre -a comme ceci « ls -a », nous afficherons alors également les fichiers et dossiers cachés
Pour cacher un fichier ou un dossier sous linux, on met un « . » (point) devant. Il existe des
paramètres dits « longs », pour les utiliser nous mettons deux tirets «(« - ») au lieu d'un. A la place de
« ls -a », nous aurions pu taper « ls --all », le paramètre existe en version courte et longue. De même
nous pouvons combiner plusieurs paramètres ensembles, ainsi je peux lancer la commande « ls -al »
qui me montrera les fichiers et dossiers cachés mais qui me donnera également d'autres
renseignements comme les droits des dossiers ou fichiers du répertoire listé. Nous verrons tout à
l'heure dans l'utilisation du man, comment choisir le paramètre à passer en fonction de l'action voulue.

III. Retrouver les commandes sous Linux


On peut retrouver facilement une commande sous Linux, tout d'abord si on se rappelle d'une
partie de celle-ci, on peut essayer l'auto-complétion. Par exemple, nous voulons afficher la date
courante et nous ne nous souvenons plus de la commande. On va taper « da » et appuyer 2 fois sur la
touche Tab, le système va alors nous proposer les différentes commandes commençant par « da » dont
celle qui nous intéresse: « date ».

Une autre solution pour retrouver une commande dont l'on ne se souvient plus mais que l'on a
déjà utilisée récemment est de remonter les commandes dans l'ordre à l'aide de la flèche « vers le
haut » quand on est dans une console. Si l'instruction n'est pas très récente tapez« history » en invite
de commande. Cette commande peut vous afficher les 500 dernières commandes lancées(chiffre
variant en fonction des distributions). Enfin dans le cas d'une commande compliquée comprenant de
nombreux paramètres, vous pouvez appuyer sur les touches « Ctrl » et « R » en même temps (Ctrl
+R)et l'ordinateur se mettra en mode "recherche d'une commande tapée" (R comme Recherche). Là,
vous pouvez taper n'importe quelle suite de lettres correspondant à une vieille commande. Par
exemple, faites Ctrl + R puis tapez "all". Linux retrouve la commande "ls --all" qui contenait
justement le mot "all". Vous n'avez plus qu'à taper Entrée pour relancer la commande !

IV. L'arborescence Linux


Pour afficher l'arborescence Linux nous allons Utiliser la commande ls. La racine (ou sommet)
de l'arborescence linux est le « / », tapez « ls -l /» pour voir celle-ci. Sous linux, on se promène dans
l'arborescence à l'aide de la commande « cd » (change directory) et en séparant les répertoires par le
slash « / », ex: cd /home/. Attention tous les répertoires se trouvant directement à la racine
nécessiterons le « / » devant si vous voulez les explorer. Une fois dans ces répertoires, vous pouvez
vous y déplacer normalement Deux commandes très usitées sous linux « pwd » et « whoami », la
première vous indique où vous êtes dans l'arborescence linux, la seconde qui vous êtes

*Quelques explications sur l'arborescence Linux:


➢ bin : contient des programmes (exécutables) qui sont susceptibles d'être utilisés par tous les
utilisateurs de la machine.
➢ boot : fichiers permettant le démarrage de Linux.
➢ dev : fichiers contenant les périphériques. Ce dossier contient des sous-dossiers qui
"représentent" chacun un périphérique. On y retrouve ainsi par exemple le fichier qui
représente le lecteur CD.
➢ etc : fichiers de configuration.
➢ home : répertoires personnels des utilisateurs. Vous y placerez vos fichiers personnels.
Chaque utilisateur de l'ordinateur possède son dossier personnel. Par exemple,
"/home/igi110/". S'il y avait un autre utilisateur (appelons-le igi111) sur l'ordinateur, il aurait
eu droit lui aussi à son propre dossier : "/home/igi111/".
➢ lib : dossier contenant les bibliothèques partagées (généralement des fichiers .so) utilisées par
les programmes.
➢ media : lorsqu'un périphérique amovible (comme une carte mémoire SD ou une clé USB) est
inséré dans votre ordinateur, Linux vous permet d'y accéder à partir d'un sous-dossier de
"media". On parle de montage.
➢ mnt : c'est un peu pareil que media, mais pour un usage plus temporaire.
➢ opt : répertoire utilisé pour les add-ons de programmes.
➢ proc : contient des informations système.
➢ root : c'est le dossier personnel de l'utilisateur "root". Normalement, les dossiers personnels
sont placé dans "home". mais celui de root fait exception. En effet, root est le super-utilisateur,
l'administrateur de la
➢ machine en quelque sorte.
➢ sbin : contient des programmes système importants.
➢ tmp : dossier temporaire utilisé par les programmes pour stocker des fichiers.
➢ usr : c'est un des plus gros dossiers, dans lequel vont s'installer la plupart des programmes
demandés par l'utilisateur.
➢ var : ce dossier contient des données "variables", souvent des fichiers, des logs (traces écrites
de ce qui s'est passé récemment sur l'ordinateur), etc.

V. Les fichiers
Sous Unix, les fichiers peuvent être de 5 types différents :
➢ Exécutable:Les fichiers exécutables correspondent à des programmes (écrits en langage C
généralement). Il n'est pas conseillé de tenter de les éditer à l'aide d'un éditeur de texte traditionnel
: il n'apparaîtra que des caractères bizarres et incompréhensibles. Seules les chaînes de caractères
stockées en constantes dans l'exécutable seront visibles. Mais en général la taille d'un exécutable
devrait vous en dissuader.
➢ Répertoire:Les répertoires, nous l'avons vu plus haut, sont des ensembles de fichiers et de
répertoires. Un répertoire peut ne contenir aucun fichier. Mais en revanche, un répertoire contient
toujours un répertoire parent et un répertoire courant.
➢ Les liens (ln)Les liens sont des fichiers assez spéciaux puisqu'il permettent d'associer plusieurs
noms à un seul et même fichier. Pour créer un lien, utiliser la commande « ln ». L'utilité des liens
est évidente puisqu'ils permettent à partir d'un seul fichier physiquement présent sur l'espace
disque, d'avoir plusieurs références de noms différents et localisées en des lieux différents d'un
même fichier qu'il n'est plus besoin de copier. Lorsque le fichier pointé est volumineux, l'emploi
des liens est donc très avantageux.

Les liens peuvent êtres de deux types :


➢ Lien symbolique:Un lien symbolique est un simple pointeur vers un autre fichier bien réel. La
commande ln -s permet de créer un lien symbolique sur un fichier. Ce lien sera présent sous la
forme d'un fichier dont le nom sera affiché après le symbole @.
Syntaxe : ln -s nom-du-fichier-à-pointer nom-du-lien-symbolique
➢ Lien physique:Un lien physique sur un fichier est un fichier qui occupe exactement le même
espace disque que le fichier vers lequel il pointe. Ainsi les deux fichiers : le lien et le fichier pointé
sont physiquement les mêmes bien que virtuellement (pour le système de fichiers) ils portent des
noms différents et puissent être localisés dans des répertoires différents.
Syntaxe : ln nom-du-fichier-à-pointer nom-du-lien-symbolique.
Vous aurez remarqué ici l'absence de l'attribut -s réservé aux liens symboliques.
➢ Fichier:Un fichier est de type fichier lorsqu'il est "tout à fait normal", qu'il n'a rien de particulier ;
c'est-à-dire lorsqu'il n'est ni un exécutable, ni un répertoire et ni un lien.
➢ Fichier cachéLes fichiers et répertoires cachés se distinguent des autres par la seule présence d'un
point (.) en première position dans leur nom. La commande de listage des fichiers ne les affichera
pas par défaut. Une commande souvent utilisée pour créer un fichier sous linux est la commande
« touch ».ex :touch toto.txt
VI. La gestion des droits sous Linux
La gestion des droits de fichiers Linux s'effectue suivant 3 orientations : le droit de lecture
(Read), le droit d'écriture (Write) et le droit d'exécution (eXecute).
➢ - Le droit de lecture permet de lire le contenu d'un fichier.
➢ - Le droit d'écriture permet la modification et la suppression d'un fichier.
➢ - Le droit d'exécution sur des fichiers binaires ou shells permet de lancer le programme.
En version numérique :
➢ Read = 4
➢ Write = 2
➢ eXecute = 1
Appliquées à un répertoire, ces définitions sont sensiblement différentes.

Code d'accès Signification Fichier Répertoire


r Read Le fichier peut etre lu Le répertoire peut etre
listé(exemple : obtenir
les fichiers contenus
dans ce répertoire par la
commande ls)
w Write Le contenu du fichier Dans le répertoire, on
peut être modifié ou ses peut supprimer, créer ou
attributs modifiés modifier un fichier
x eXecute Le fichier peut être On peut entrer dans ce
exécuté répertoire, qui devient
notre répertoire courant

Chacun de ces droits sont attribués à 3 types de personnes : le propriétaire (owner ou UID), le
groupe (group ou GID) et le reste du monde (other). La commande utilisée pour lister les droits sur les
fihiers ou répertoires est la commande « ls -l ». Créons un fichier test.txt et visualisons les droits sur
ce fichier:

Figure 1: Les droits sous Linux

Le premier champ décrit le type du fichier ( « - »: fichier normal, « d » répertoire, « l »: lien


symbolique.). et les droits d'accès (r : lecture, w : écriture, x : exécution) pour, successivement, le
propriétaire, son groupe et les autres utilisateurs. Le deuxième champ affiche le nombre de liens du
fichier.

Dans le troisième et le quatrième champs on trouve respectivement le nom du propriétaire du


fichier et celui de son groupe.

Les champs suivants décrivent respectivement la taille (en octets), la date et l'heure de la
dernière modification et le nom du fichier.
Nous disposons de la commande « chmod » pour changer les droits d'un fichier ou d'un
répertoire.Je veux par exemple modifier les droits du fichier « test.txt » créé précédemment , pour
donner les droits en écriture au groupe. Je vais donc faire « chmod g+w test.txt », on utilise ici le
moyen dit « littéraire » pour modifier les droits avec « u » pour user, « g » pour groupe, « o » pour
other et les opérandes « + » et « - » pour ajouter ou enlever des droits, à noter on peut aussi utiliser
« a » pour « all » si on veut modifier un droit pour tout le monde.

On peut également utiliser la méthode numérique de la façon suivante: r=4, w=2, x=1. Donc si
je veus donner les droits rwx rw-r-- au fichier « test.txt », je peux directement taper :
« chmod 764 test.txt ».

Figure 2: Affectation des droits

Cas spécial : « setuid et setgid »:

Le « setuid » et le « setgid » sont deux attributs qui permettent de modifier les droits du
processus créés par l'exécution du fichier. Si le « setuid » est activé, quand le fichier est exécuté par
un utilisateur, le processus a les mêmes droits que le propriétaire du fichier en cours d'exécution. Pour
le « setgid », vous avez donc deviné qu'il s'agissait d'un héritage des droits du groupe et non du
propriétaire du fichier.

Pour les activer, il vous suffit d'ajouter ou supprimer le flag "s" sur le propriétaire ou le groupe.
Vous voulez, par exemple, rendre un script exécutable par d'autres personnes que le propriétaire, vous
pouvez alors mettre le bit « s » sur l'utilisateur pour rendre lancer le script avec les droits de
l'utilisateur: « chmod u+s test.sh », avec les droits du groupe « chmod g+s test.sh ».

VII. Les variables.


Le shell permet de définir des variables, comme la plupart des langages de programmation.
Une variable est une donnée à qui l'on attribue un nom.Lorsque vous assignez une valeur à une
variable (avec l'opérateur « = »), vous pouvez alors accéder à cette variable en rajoutant un `` $''
devant son nom, voici un exemple: « toto= "voici une variable" », « echo $toto ».

Figure 3: Les variables


On peut également affecter à une variable le résultat d'une commande en utilisant les back
quotes « ` » (AltGr+7) ex: « nbligne=` more test.txt |wc -l` »

En informatique, les variables d’environnement sont des variables dynamiques utilisées par
les différents processus d’un système d’exploitation Vous pouvez les afficher par la commande
« env ». Une des plus importantes pour le lancement des commandes est la variable
« PATH »(attention les majuscules sont importantes), vous pouvez afficher celle ci avec la commande
« echo $PATH ». Cette variable renseigne le système sur le chemin des commandes que vous tapez.
Figure 4: La variable PATH
Si vous voulez rajouter un chemin où trouver des commandes à votre PATH(par exemple
l'endroit où vous stockez vos scripts) vous devez utiliser la commande suivante:
« export PATH=$PATH:/home/user/mes_prog » pour avoir le répertoire en dernier dans PATH. ou
« export PATH=/home/user/mes_prog/:$PATH » pour avoir le répertoire en premier dans PATH.

Figure 5: Ajouter un chemin dans la variable PATH

Attention ceci ne sera valable que pour la session en cours, si vous voulez configurer PATH de
façon permanente vous devez éditer le fichier de configuration de votre shell de connexion. Comme le
plus souvent c'est le shell BASH qui est utilisé, vous devez éditer votre fichier /home/user/.bashrc.
Pour ça vous utiliserez un éditeur de texte ou tout simplement une commande pour vous faciliter la
tâche. Eh oui, souvent l'utilisation de la ligne de commande rend les choses bien plus faciles que
l'utilisation de la souris, surtout dans les tâches d'administration. Voilà la commande:
« echo 'export PATH=$PATH:/home/user/mes_prog' >> /home/user/.bashrc »
Ainsi à chaque connexion votre PATH contiendra votre répertoire « /home/user/mes_prog ». Cette
opération peut être exécutée par l'utilisateur user vu qu'il s'agit de son environnement.

On peut chercher l'existence d'une commande en utilisant soit « whereis » soit « which »:
« whereis commande », « which -a commande ». Dans le cas de which l'option -a nous permet de voir
tous les chemins correspondants. Sans l'option -a ce n'est que le 1er répertoire qui contient la
commande qui sera affiché, chose qu'on ne voudra sûrement pas si la commande se trouve dans
plusieurs répertoires.

VIII. Les commandes en shell.


Lors de l'exécution d'une commande en shell, un processus est créé. Celui-ci va alors ouvrir
trois flux:
➢ stdin, appelée entrée standard, dans lequel le processus va lire les données d'entrée. Par défaut
stdin correspond au clavier ; STDIN est identifié par le numéro 0.
➢ stdout, appelée sortie standard, dans lequel le processus va écrire les données de sortie. Par défaut
stdin correspond à l'écran ; STDOUT est identifié par le numéro 1.
➢ stderr, appelée erreur standard, dans lequel le processus va écrire les messages d'erreur. Par défaut
stderr correspond à l'écran. STDERR est identifié par le numéro 2.

Entrées-sorties standard : STDOUT, STDIN, STDERR


Par défaut lorsque l'on exécute un programme, les données sont donc lues à partir du clavier et
le programme envoie sa sortie et ses erreurs sur l'écran, mais il est possible de lire les données à partir
de n'importe quel périphérique d'entrée, voire à partir d'un fichier et d'envoyer la sortie sur un
périphérique d'affichage, un fichier, etc. Linux, comme tout système de type Unix, possède des
mécanismes permettant de rediriger les entrées-sorties standards vers des fichiers. Ainsi, l'utilisation
du caractère «>» permet de rediriger la sortie standard d'une commande située à gauche vers le fichier
situé à droite , on peut du même coup créer le fichier.

Figure 6: Les redirections en SHELL

Si vous désirez ajouter du texte au fichier existant, vous devez utiliser lle caractère « >> », celui-ci
sera alors ajouté au texte existant.

Figure 7: Les doubles redirections en SHELL

Il est possible également d'exécuter plusieurs commandes sur une même ligne en séparant
celles-ci par un point-virgule. ex: « nb=3;echo "le nombre est " $nb ». Une autre manière de taper
plusieurs commandes est d'utiliser le « && » (double et commercial), dans ce cas les commandes
s'enchaînent en vérifiant au préalable que la première s'est exécutée correctement.
ex: « ls -l && echo "bonjour" »

En SHELL, on utilise également les « pipes », les tubes (en anglais «pipes", littéralement
tuyaux) constituent un mécanisme de communication propre à tous les systèmes Unix et Linux. Un
tube, symbolisé par une barre verticale (caractère «|», AltGr+6), permet d'affecter la sortie standard
d'une commande à l'entré standard d'une autre, comme un tuyau permettant de faire communiquer
l'entrée standard d'une commande avec la sortie standard d'une autre.

Ainsi dans l'exemple suivant, la sortie standard de la commande ls -al est envoyée sur le
programme sort chargé de trier le résultat par ordre alphabétique :
« ls -al | sort »

Il est possible de cette façon de chaîner un certain nombre de commandes par tubes successifs.
Dans l'exemple suivant la commande affiche tous les fichiers du répertoire courant, sélectionne les
lignes contenant l'extension « .txt »(grâce à la commande grep) et compte le nombre de lignes
total:« ls -l | grep .txt | wc -l », vous commencez ainsi à entrevoir toute la puissance du shell!

Figure 8: Les « pipe » sous Linux


Vous pouvez lancer des applications graphiques à partir de la ligne de commande, lancer par exemple
« xterm », vous verrez alors s'ouvrir un terminal.Mais ce terminal est toujours lié à votre première
invite de commande, pour le rentre autonome, il vous faudra taper « Ctrl+Z, puis « bg », la première
commande stoppe son exécution la seconde met le processus en background vous rendant ainsi la
main sur votre console initiale.
Quelques commandes usuelles:
➢ morefichier: affiche le contenu du fichier page/page
➢ cat fichier affiche le contenu du fichier en entier
➢ whoami: indique l'utilisateur courant (pratique quand on passe en mode root)
➢ echo " expression": affiche ce qui est entre guillemets à l'écran ou le contenu d'une variable
➢ ls:affiche le contenu d'un répertoire
➢ pwd: affiche le chemin courant
➢ which, whereis donne le chemin d'une commande
➢ ps: affiche les processus en cours
➢ touch :crée un fichier
➢ mkdir: crée un répertoires
➢ rm : supprime un fichier, avec l'argument -r peut supprimer récursivement un répertoire et son
contenu
➢ sort:trie un fichier en fonction des arguments passés à la commande
➢ grep: affiche les lignes contenant le motif (chaîne de caractères) recherché
➢ tail:affiche le bas d'un fichier
➢ head:affiche le haut d'un fichier
➢ du: évalue l'espace disque d'un répertoire ou fichier
➢ wc:Affiche le nombre de lignes, de mots et d'octets d'un fichier
➢ cut: Découper une ligne de fichier en fonction d'un séparateur.
➢ read: Lit depuis un descripteur de fichier (en standart ce qui est tapé au clavier)
➢ find: Rechercher des fichiers dans une hiérarchie de répertoires

IX. Utilisation du man


Les pages de manuel sont accessibles depuis l'invite du shell en tapant la commande man et le
nom de l'exécutable. Par exemple, pour obtenir la page de manuel relative à la commande ls,
entrez:« man ls ». Le champ NAME donne le nom de l'exécutable et une brève explication sur ses
fonctions. Le champ SYNOPSIS indique l'utilisation courante de l'exécutable, comme les options
déclarées et les types d'entrée (fichiers ou valeurs) pris en charge par l'exécutable. Le champ
DESCRIPTION donne les options et les valeurs disponibles associées à un fichier ou à un exécutable.
See Also (Voir aussi) indique les termes, fichiers et programmes associés.

Figure 9: Le man

Pour naviguer dans la page de manuel, vous pouvez utiliser les touches [Flèches bas] (Page
Down) et [Flèches haut] (Page Up) ou utiliser la [Barre espace] pour avancer d'une page et « B » pour
reculer. Pour quitter la page de manuel, tapez « Q ».

Pour chercher des mots dans une page de manuel, tapez « / », puis un mot ou une phrase et
appuyez sur [Entrée]. Toutes les occurrences du mot seront en surbrillance dans toute la page de
manuel, vous permettant ainsi de lire rapidement le mot recherché dans son contexte.

Comme toute autre commande, man possède sa propre page de manuel. Tapez « man man » à
l'invite du shell pour obtenir de plus amples informations.

X. Les Processus
On appelle processus, un programme chargé en mémoire centrale et en cours d'exécution. Il est
géré par le système d'exploitation. Chaque processus peut créer lui-même des processus. Ces
nouveaux processus sont alors appelés processus enfants (child process). Un pseudo processus est
crée au moment du démarrage du système et a comme PID le numéro 0. Il crée lui-même un
processus enfant, avec le numéro 1. Le processus numéro 1 est appelé processus init. Ce processus
init est responsable de tous les processus en cours dans le système. Il permet d'afficher à l'écran le
login et d'utiliser le shell.

La succession de processus

On peut, enchaîner l'exécution de plusieurs processus de façon totalement indépendante et en


séquence : le déroulement du premier n'influe pas sur celui du second, qui n'est lancé qu'à la fin de
son exécution.
« date;whoami;ls;echo "fin de commande" »

Les commandes sur les processus


➢ top:La commande top vous permet d'afficher des informations en continu sur l'activité du
système. Elle permet surtout de suivre les ressources que les processus utilisent (quantité de la
RAM, pourcentage de CPU, la durée de ce processus depuis son démarrage).
Options :
● -d spécifie un délais de rafraîchissement (en secondes)
● -k stopper un process de manière interactive en cours d'utilisation, taper ensuite le nom du signal
à envoyer: 15 (SIGTERM), met fin à un process, 9 (SIGKILL) est plus brutal, touche "q" quitte
top
➢ La commande ps avec des arguments permet de lister les processus du user.
➢ ps -fe : donne tous les processus, avec leur numéro PID
➢ ps --help ou man ps: indique toutes les options de cette commande (elles sont nombreuses)
On ouvre une console et on tape simplement : ps -fe. Le résultat de cette commande nous donne
une série de lignes (incompréhensibles quand on débute sous Linux :P). Pas de panique, ce n'est
pas le gestionnaire des taches de Windows, Linux n'a rien à cacher à ses utilisateurs, il donne
simplement les processus lancés à l'instant où vous lancez la commande. Quelques explications en
image :

Figure 10: La commande top


● Quelques explications en image : Commande ps -fe

Figure 11: Les différents champs de la commande ps -fe et leur signification


➢ UID : Numéro d'utilisateur (User IDentification) ayant lancé le processus
➢ PID : Numéro unique du processus (Process IDentification)
➢ PPID : Numéro du processus parent (Parent Process IDentification)
➢ C : cpu utilization , pourcentage de CPU utilisé
➢ STIME : correspond à l'heure de lancement du processus
➢ TTY : correspond au nom du terminal
➢ TIME : correspond à la durée de traitement du processus
➢ CMD : correspond à la ligne de commande ayant généré le processus
➢ Avec cette commande, la liste peut être très longue. Comme vous pouvez le constater sur l'image
ci-dessous, les différents processus sont classés en zones qui nous permettrons par la suite de
l'article, de voir et d'optimiser certains d'entre eux.
Autres options :
➢ ps -x visualise tous les processus actifs de l'utilisateur courant (y compris ceux qui ne sont pas liés
à un terminal). (Les commandes qui ne sont pas associées à un terminal sont reconnaissables par
le point d'interrogation qui rempli le champ TTY.)
➢ ps -ax visualise tous les processus de la machine de tous les utilisateurs
➢ ps -aux affiche les utilisateurs associés à chaque processus

D'autres champs nous donnent plus d'indications :


➢ Le champ "USER" indique l'utilisateur du processus.
➢ Le champ "%CPU" donne les ressources du microprocesseur utilisées par le processus
➢ Le champ "%MEM" indique les ressources en mémoire vive utilisées par le processus
➢ Le champ "RSS" donne réellement la mémoire utilisée en kilobytes par le processus
➢ Le champ "START" indique l'heure à laquelle le processus a été lancé.
Figure 12: Les différents processus affichés
La commande pstree permet d'afficher les processus et de voir leurs processus dépendants :

Figure 13: L'arbre des processus

Pour arrêter un processus, on peut lui envoyer différents signaux (pour en savoir plus sur les
signaux) :
kill PID : met fin normalement à la tâche
kill -9 PID : action si nécessaire encore plus radicale !
La commande "kill" permet d'envoyer un signal à un processus en cours pour l'arrêter par
exemple
➢ Kill PID: arrêt du processus

➢ kill -9 PID: en cas d'échec d'arrêt du processus (manière forte)

➢ killall: permet de tuer un processus en indiquant le nom du processus au lieu d'indiquer le


PID
➢ Une commande peut être à l'origine de plusieurs processus.

➢ killall grep:Tue tous les processus qui contiennent la commande grep.

➢ l'option "-i":vous demande une confirmation avant de tenter d'arrêter un processus.

➢ Vous pouvez également lancer la commande xkill et tuez un processus avec la souris en
cliquant dessus.

Mettre un processus en tâche de fond

Unix est un système multi-tâches, c'est-à-dire qu'il peut exécuter plusieurs programmes à la fois.
Un processus est une instance d'un programme en train de s'exécuter, une tâche. Le shell crée un
nouveau processus pour exécuter chaque commande.
Si on lance une commande qui prend beaucoup de temps (comme un calcul, ou une nouvelle
fenêtre), on peut l'interrompre par Control-C. Ceci interrompt (définitivement) la commande. On peut
aussi exécuter une commande en tâche de fond. Le shell rend alors la main avant la fin de la
commande. Pour le faire, on ajoute un « & » à la fin de la commande ; par exemple :
« chaland ~ $ cc -o grosprogramme grosfichier.c & »
« chaland ~ $ xdvi monrapport.dvi & »

Dans le premier exemple, on lance le compilateur cc en parallèle avec le shell; dans le second
exemple, on met le dvi en tâche de fond, ce qui évite d'avoir à le relancer à chaque modification.

On reprend la main immédiatement, sans attendre la fin de l'exécution de la commande. On peut


donc taper d'autres commandes dans le même terminal, pendant que la précédente s'exécute.

background et foreground
Comme on vient de le voir, si vous avez pensé à terminer votre ligne de commande par une
esperluette, le programme que vous avez lancé tourne en arrière-plan (background, abrégé en
bg).

Si vous avez omis l'esperluette, le programme prend la précédence sur le shell. On dit qu'il
tourne au premier plan (foreground, abrégé en fg). Les lignes tapées au clavier sont mémorisées mais
ne seront pas exécutées par le shell avant que le programme en cours d'exécution n'ait fini son calcul.
Vous pouvez malgré tout faire passer ce programme en tâche de fond, grâce à la manipulation
suivante :
chaland ~ $ xdvi rapport.dvi
^Z (^= touche Contrôle-Ctrl)
zsh: suspended xdvi rapport.dvi
chaland ~ $ bg
[1] + continued xdvi rapport.dvi
chaland ~ $

Figure 14.: Mettre un processus en arrière plan

^Z est un signal intercepté par le shell, qui suspend l'exécution du programme sans détruire le
processus correspondant. Les calculs déjà effectués par ce programme ne sont pas perdus. Dans
l'exemple précédent, si on demande à un xdvi suspendu de changer de page (SPC), il ne le fera pas,
mais il se souviendra de le faire dès qu'il aura à nouveau accès aux ressources de l'ordinateur. À partir
de l'état suspendu, on peut faire passer un programme :
➢ au premier plan, en tapant fg ;

➢ en arrière-plan, en tapant bg.

Son exécution reprend alors là où on l'avait laissée.

Quand il n'y a qu'un seul programme en arrière-plan dans le terminal courant, on peut le faire
passer au premier plan en tapant fg. Cela permet en particulier d'interrompre son exécution grâce à
^C, que la plupart des programmes comprennent.^C n'affecte que l'éventuel unique programme qui
tourne au premier plan dans le terminal où il est tapé. Quand il y en a plusieurs, c'est un peu plus
compliqué, mais c'est bien sûr possible.

Vous pouvez pratiquer ^C, ^Z, fg, bg de façon visuelle et didactique en lançant la commande
« xdaliclock -seconds -geometry 500x100+0+0 -font BUILTIN » et en observant attentivement
les secondes (pensez à en laisser quelques-unes s'écouler). Vous remarquerez que ce
programme finit la transition en cours avant de se remettre à l'heure.

Résumé :
Le programme tourne au premier plan :
➢ ^Z le suspend ;

➢ ^C l'interrompt.

Le programme est suspendu :


➢ fg le passe au premier plan ;

➢ bg le passe en arrière-plan.

Le programme tourne en arrière-plan :


➢ si c'est le seul dans ce cas, fg le passe au premier plan ;

➢ sinon, c'est plus compliqué.

Le programme ne tourne pas :


➢ il n'y a rien à faire...

XI. L'éditeur VIM en mode console


Sous Linux, vous avez en mode console, la possibilité de vous servir d'un éditeur de texte très
connu « vi », de nombreuses distributions vous proposent d'ailleurs un vi amèlioré « Vim ».
Pour lancer vim sur un fichier : vim toto
Pour lancer vim sur plusieurs fichiers :vim toto tata titi, on passe d'un buffer à l'autre avec :n
(vers l'avant) ou :N (vers l'arrière)
Une sauvegarde automatique du buffer courant se trouve dans .toto.swp. Après un crash on peut
tenter de récupérer le fichier avec la commande vim -r toto.

Les différents modes:

Au démarrage l'éditeur est en mode ``commande'', pour passer en mode ``insertion'' il faut taper la
commande ``i'', pour en sortir appuyer sur la touche ESC.

mode commande

➢ :w pour sauver sans sortir

➢ :w toto pour sauver sous le nom toto

➢ :x pour sauver et sortir ou :wq

➢ :q! pour sortir sans sauver

Les déplacements

➢ h déplace le curseur vers la gauche


➢ l déplace le curseur vers la droite
➢ j déplace le curseur vers le bas
➢ k déplace le curseur vers le haut
➢ . désigne la ligne courante
➢ 0 va en début de ligne
➢ $ va en fin de ligne
➢ I insertion en début de ligne (Insert)
➢ A insertion en fin de ligne (Append)
➢ w avance d'un mot (word)
➢ b recule d'un mot (back)
➢ :n va à la ligne n
➢ { début de paragraphe
➢ } fin de paragraphe
➢ ( début de phrase
➢ ) fin de phrase
➢ G va à la fin du fichier
➢ * le curseur étant sur un mot, permet d'avancer à l'occurrence suivante du mot (rem : N*)
➢ # idem en reculant (rem : N#)
➢ % si le curseur est positionné sur (, {, $ [$, on avance à ), }, $ ]$ (très utile en programmation !)

remarque : on peut répéter N fois la plupart des commandes précédentes par exemple Nl déplace le
curseur de N caractères vers la droite. d} efface jusqu'à la fin du paragraphe, c2) supprime les 2
prochaines phrases et passe en mode insertion, 3{ remonte au début du 3ème paragraphe précédent.

Commandes utiles dans les combinaisons


➢ x efface le caractère sous le curseur
➢ d effacer
➢ c changer
➢ y copier (yank)
➢ r remplacer un caractère
➢ R remplacer plusieurs caractères
➢ s effacer un caractère et passer en mode insertion
➢ D effacer la fin de ligne
➢ C changer la fin de ligne
➢ o ouvrir une ligne après la ligne courante
➢ O ouvrir une ligne avant la ligne courante

exemples :

➢ dw efface la fin du mot, dd efface la ligne,


➢ pour changer la fin d'un mot, on se place à l'endroit à modifier, on tape cw et on écrit le nouveau
mot
➢ cc vide la ligne
➢ yw copie un mot dans le tampon
➢ yy ou Y copie une ligne dans le tampon
➢ p colle le tampon (paste) après le curseur
➢ P colle le tampon sur le curseur
➢ ddp permet d'inverser deux lignes
remarque : on peut répéter N fois les commandes précédentes par exemple Ndd efface N lignes.
Mode visuel
Plusieurs façons de sélectionner une portion de texte.
➢ v permet de passer en mode visuel, les déplacements habituels permettent de sélectionner le texte
➢ V mode visuel ligne à ligne
➢ CTRL v mode visuel en bloc (utile pour des portions de tableaux)
Gestion des fenêtres
➢ CTRL w n : crée une fenêtre horizontale vide
➢ :split : crée une fenêtres horizontale avec le même fichier
➢ CTRL w v ou CTRL w CTRL V ou vsplit: crée une fenêtre verticale avec le même fichier
➢ CTRL w + ou CTRL w - redimensionnement horizontal
➢ CTRL w ou CTRL w redimensionnement vertical
➢ CTRL w K ou J ou H ou L permet de passer d'une fenêtre à l'autre
Mappage des touches clavier
exemple : pour commenter une ligne en langage C :
:map $ <$F12$ >$ 0i/* $ <$ESC$ >$ $a*/ $ <$ESC$ >$
remarque : dans le mapping ci-dessus, $ <$F12$ >$ est réellement la suite des 5 caractères $ <$F12$
>$
Historique des commandes
➢ q: affiche une fenêtre avec l'historique des commandes
➢ q/ cherche dans l'historique
Digraphs
➢ :digraphs Affiche les codes permettant l'accès aux caractères qui ne sont pas au clavier.
➢ :digraphs ye 165 affecte le code ascii 165 à la séquence ye.

Pour insérer un digraph taper CTRL k + code,


exemple : CTRL k Co pour le copyright ©.
Divers
➢ CTRL u (en mode insertion) efface les caractères avant le curseur dans la ligne courante
➢ u annule la dernière commande
➢ redo ou CTRL r annule la dernière annulation
➢ `` retourne à la position précédent le dernier déplacement
➢ . répète la dernière commande
➢ J colle la ligne suivante à la ligne courante
➢ ~ permet de changer la casse
➢ gq associé à un déplacement permet de reformatter le texte, exemple gq} reformatte jusqu'à la fin
du paragraphe
➢ :2,4co6 copie les lignes 2 à 4 après la ligne 6
➢ :.,+2mo3 déplace la ligne courante et les deux suivantes à après la ligne 3
Interaction avec d'autres programmes
➢ avec la commande less, si on tape v le buffer est envoyé dans vi
➢ vim http://www.toto.fr/index.php charge index.php dans vi
➢ :!commande permet de lancer une commande du shell (ex: :!ls -l)
➢ :!bash permet de lancer un shell complet
➢ :r toto permet d'insérer le fichier toto
➢ :r! date permet d'insérer la date du système
➢ :r!ls -l permet d'insérer la liste des fichiers du répertoire courant

Site tutoriel sur Vim: http://www.tuteurs.ens.fr/unix/editeurs/vim.html


XII. Ecrire son premier script:(test,boucles..)
Un shell-script (ou script shell) est un fichier texte simple. Il peut donc être écrit avec votre
éditeur de texte préféré,.Comme nous venons de voir, utiliser vim vous donnera des habitudes qui
vous permettrons d'écrire ou modifier des scripts en mode console, ce qui arrive souvent en
administration système.. La toute première ligne du fichier doit contenir le nom de l'interpréteur à
utiliser (cela est valable pour tous les langages de script). Cette ligne doit commencer par #! suivi de
l'exécutable à utiliser. Pour un shell-script bash, on aura donc en début de fichier :
« #!/bin/bash »

Ce fichier doit également être exécutable. Pour cela on lui attribuera ces droits à l'aide de
chmod. Si le fichier s'appelle mon_programme, on peut le faire de cette manière :
« chmod +x mon_programme » (Pour plus de détails sur les options de chmod, voir le chapitre VI)
A présent, on peut dans ce fichier mettre des commandes shell ou appeler des programmes comme on
le ferait dans une ligne de commande. Ensuite il sera invoqué en tapant son nom comme pour
n'importe quel autre exécutable. On peut insérer des commentaires dans un script. Ce sont des lignes
qui seront ignorées par le bash. A partir d'un # tout le reste de la ligne est considéré comme un
commentaire:
« #Ceci est un commentaire »
« echo ceci est affiché #Un autre commentaire »

Un script se termine lorsque la dernière ligne a été exécutée. On peut toutefois forcer sa sortie
avant en utilisant la commande exit. Le code de retour du script sera celui de la dernière commande
exécutée. Cela à moins de préciser une valeur numérique à la suite de exit. C'est alors celle-ci qui sera
renvoyée.

Les variables spéciales.

Lorsqu'un shell-script est exécuté, bash initialise certaines variables particulières qui sont alors
accessibles en lecture seule. C'est à dire qu'elles ne peuvent pas être directement modifiées par une
affectation.

La première pré-définie est « $$ » qui contient le PID du script. Ce Process ID, ou en français
l'identifiant de processus, est un nombre qui à un moment donné identifie de manière unique une
instance de programme en cours d'exécution sur le système. Cette valeur peut servir par exemple à
générer un nom de fichier temporaire ou pour envoyer un signal.

Ensuite on trouve « $? » dont la valeur va changer au fil de l'exécution du script. Il contiendra


le code de retour de la dernière commande exécutée. A noter qu'un code de retour de 0 signifie qu'il
n'y a eu aucune erreur. Si cette valeur est différente de 0, il s'agit d'un code d'erreur.

Il y a aussi les paramètres passés lors de l'appel au script. La variable $* contient l'ensemble de
toutes ces valeurs et $# permet de connaître leur nombre. Pour accéder à un paramètre en particulier,
on utilisera une des variables positionnelles $1, $2, $3, ... Pour celles après 9, il faut encadrer le
nombre par des accolades : ${10}, ${11}, ${12}....

La variable $0 contient le nom du script tel qu'il a été lancé, c'est-a-dire avec les spécifications
de chemin éventuelles.

Construction de test

Une construction if/then teste si l'état de la sortie d'une liste de commandes vaut 0 (car 0 indique
le « succès » suivant les conventions UNIX) et, dans ce cas, exécute une ou plusieurs commandes.Il
existe une commande dédiée appelée [ (caractère spécial crochet gauche). C'est un synonyme de test,
qui est intégré pour des raisons d'optimisation. Cette commande considère ses arguments comme des
expressions de comparaisons ou comme des tests de fichiers et renvoie un état de sortie correspondant
au résultat de la comparaison (0 pour vrai et 1 pour faux).

Avec la version 2.02, Bash a introduit la commande de test étendue [[ ... ]], réalisant des
comparaisons d'une façon familière aux programmeurs venant d'autres langages. Notez que [[ est un
mot clé, pas une commande. Bash considère « [[ $a -lt $b ]] » comme un seul élément, renvoyant un
état de sortie.

Les constructions (( ... )) et let ... renvoient aussi un état de sortie de 0 si les expressions
arithmétiques qu'elles évaluent se résolvent en une valeur non nulle. Ces constructions d'expansion
arithmétique peuvent donc être utilisées pour réaliser des comparaisons arithmétiques.

let "1<2" renvoie 0 (car "1<2" se transforme en "1")


(( 0 && 1 )) renvoie 1 (car "0 && 1" donne "0")
Un if peut tester n'importe quelle commande, pas seulement des conditions entourées par des
crochets.
if cmp a b &> /dev/null # Supprime la sortie.
then echo "Les fichiers a et b sont identiques."
else echo "Les fichiers a et b sont différents."
fi
La construction "if-grep" très utile:
if grep -q Bash fichier
then echo "fichier contient au moins une occurrence du mot Bash."
fi

Nous allons créer un script qui teste l'existence d'un fichier d'utilisateurs

Figure 15.: Un script qui teste l'existence d'un fichier

Nous le rendons ensuite exécutable, nous allons créer un fichier de test users.txt et nous lançons le
script sur users.txt

Figure 16: Lancement du script


La structure de contrôle "boucle for" en shell.

Cette structure de contrôle permet de lancer une liste de commandes en boucle.

Syntaxe :
for variable in liste_de_cas
do
liste_commandes
done
Dans ce modèle, liste_de_cas est une liste de chaînes de caractères, utilisant éventuellement les
métacaractères du shell.
Exemple :
for fichier in `ls *.c`
do
chmod go-r $fichier
done
Cette séquence change les droits d'accès de tous les fichiers non cachés du répertoire courant
comprenant l'extension .c
Remarques :Dans les structures de contrôle de boucles, la commande break peut être utilisée.
La syntaxe suivante :
for i
do
...
est équivalente à :
for i in $*
do
...
La variable i prend successivement la valeur de chacun des paramètres positionnels ayant reçu une
valeur.

Figure 17: Exemple de boucle for

La structure de contrôle "boucle while" en shell.


Cette structure de contrôle permet d'exécuter une séquence de commandes en boucle, tant qu'une
condition est vérifiée.
Syntaxe :
while condition
do
liste_commandes
done
Figure 18.: Une boucle while
La structure de contrôle "boucle until" en shell.
Cette structure de contrôle permet d'exécuter une séquence de commandes jusqu'à ce qu'une condition
devienne vraie.
Syntaxe :
until condition
do
liste_commandes
done

Vous aimerez peut-être aussi