Linux¶

Introduction à l’univers Linux¶

Motivation¶

L’objectif de ce document est une incursion dans l’univers Linux. Seules les notions et commandes essentielles sont abordées sans prétendre à l’exhaustivité .

Avec une lecture assidue accompagnée d’exercices pratiques , cette synthèse devrait vous permettre de vous familiariser avec l’envrionnement Linux , plus exactement GNU/Linux est un système d’exploitation libre basée sur Unix , l’ancêtre des système d’exploitation . Linux possède les avantages suivants :

Multi plateforme matérielles (PC (i386 et x86) , Macintosh , Sparc , Alpha , ARM , …)
Multi-utilisateurs ( plusieurs personnes peuvent simultanémement travailler sur la même machine )
Multi-tâches ( plusieurs applications peuvent être lancées en même temps sans qu’aucune n’affecte les autres )
Multi-processeurs

Arborescences - Les bases¶

/¶: racine contient tous les autres répertoires
/bin¶: commandes indispensables à tous les utilisateurs
/dev¶: Fichier de périphérique et de composant du système ( les disques dures de type IDE ou EIDE sont préfixés par hd comme hda, les disques SCSI sont préfixés par sd )
/etc¶: Commandes et fichiers nécessaires à l’administration du système . Seul l’administrateur doit pouvoir y lire et écrire .
/home¶: Répertoire personnel des utilisateurs
/lib¶: Librairies indispensables à Linux et à tous les programmes compilés pour ce système (librairies dynamiques partagables)
/proc¶: Répertoire d’informations sur le système
/root¶: Répertoire de l’administrateur
/sbin¶: Répertoire pour les programmes de gestion du système
/tmp¶: Contient les fichiers temporaires

Arborescences - Répertoire `/usr`¶

/usr¶: Contient les applications partagées par tous les utilisateurs
/usr/bin¶: Commandes spécifique à Linux + liens vers les commande de /bin
/usr/lib¶: Bibliothèques de sous-programmes

Arborescences - Répertoire `/var`¶

/var¶: Données variables du système
/var/cron¶: Service cron
/var/log¶: Fichiers de journalisation de Linux et de ses services

Console et commandes¶

La console est l’écran qui va nous permettre d’effectuer un ensemble d’instructions par l’intermédiaire de commandes .

Ces commandes peuvent être : simples , sans ou avec différentes options , plus ou moins sophistiquées , combinées entre elles via des tubes, …

Commandes	Utilités
`man nom_commande` / `nom_commande -help`	Accède au manuel de la commande « nom_commande »
`clear`	Nettoie l’écran de la console
`reset`	Permet de rétablir la console
`history`	Affiche l’historique des commandes tapées
`!numéro_ligne_historique`	Exécute la commande correpsondante à la ligne « numéro_ligne_historique » de l’historique quitte la console
`exit`	Quitte la console
`commande1 \| commande2`	Le résultat de la première commande « commande1 » est envoyées en entrée de la deuxième commande ici « commande2 » via un tube
`commande1 & commande2`	Les deux commandes « commande1 » et « commande2 » sont exécutées simultanément avec « commande1 » exécutée en arrière plan
`commande1 && commande2`	Exécute les commandes « commande1 » et « commande2 » uniquement si la « commande1 » est réussi .
`commande1 \|\| commande2`	La commande « commande2 » s’exécute seulement si la « commande1 » échoue
`commande1 ; commande2`	Les deux commandes « commande1 » et « commande2 » sont exécutées dans l’ordre

Quelques raccourcis claviers en mode console¶

CTRL + C¶: Arrête la commande en cours
CTRL + A¶: Place le curseur au début de la ligne
CTRL + E¶: Place le curseur à la fin de la ligne
CTRL + W¶: Coupe la chaîne de caractères avant le curseur
CTRL + K¶: Coupe la chaîne de caractères après le curseur
CTRL + U¶: Efface la ligne
CTRL + R¶: Recherche une commande dans l’historique
CTRL + L¶: Efface le contenu de l’écran excepté la ligne courante
CTRL + D¶: Quitte la console

Première rencontre¶

Commandes	Utilités
`whoami`	Affiche mon nom d’utilisateur
`hostname`	Nom de la machine sur laquelle on est connecté
`uname -a`	Affiche les informations sur la version Linux installé
`w`	Affiche les informations de connexions des différents utilisateurs
`who` / `finger`	Affiche la liste des utilisateurs connectés

Utilisateurs et droits¶

Linux est un système multi-utilisateur où chaque utilisateur à son propre compte.

Il existe donc un ensmble de règles qui définissent des droits d’accès ( lecture ,écriture , et d’exécution ) sur des objets ( répertoires , fichiers et liens ) contenus sur la machine .

Ces droits sont définis par une séquence de 10 caractères.

Le premier caractère représente le type de l’objet .

Principalement on trouve :

-¶: Fichier
d¶: Répertoire (d irectory)
l¶: Lien (l ink)

Les 9 autres caractères sont regroupés en 3 identités : l”u tilisateur , le g roupe et les autres (o ther).

Sur chaque identité on a l’information sur les droits d’accès suivants :

r¶: Lecture (r ead)
w¶: Write (w rite)
x¶: Exécution(e x ecute)

Pour pouvoir modifier ou consulter les droits d’accès on utilise ces commandes :

Commandes	Utilités
`ls -l`	Affiche les droits des objets contenus
`chmod u+x mon_script`	Donne (+) le droit (ch ange mod e) d’e x écution à l”u tilisateur du fichier « mon_script »
`chmod o-w mon_script`	Supprime le droit (-) d’écritture (w rite) aux autres (o ther) utilisateurs que le propriétaire actuel du fichier « mon_script » et ceux qui font partie du groupe .
`chmod -R ug+w,o-r mon_repertoire`	Donne (+) les droits d’écriture (w) au propriétaire (u ser) et au g roupe de manière récursive (-R) du répertoire « mon_repertoire » mais aussi (,) supprime (-) le droit de lecture (r) aux autres utilisateurs (o ther) de ce répertoire .

Les commandes chmod sont aussi réalisable en numériques .

Répertoires¶

Se positioner dans l’arboresence¶

pwd¶: Affiche mon répertoire courant (p rint w ork d irectory)
.¶: Accès au répertoire courant
..¶: Accès au répertoire parent

Chemin absolu, relatif¶

Le chemin absolu contient l’arborescence complète en partant de la racine.

Le chemin relatif contient l’arborescence à partir du répertoire courant.

Créer un répertoire¶

Commandes	Utilités
`mkdir nom_repertoire`	Crée le répertoire « rep2 » dans le répertoire « rep1 » , si le répertoire « rep1 » n’existe pas , il est alors créé
`mkdir rep1/rep2`	Crée le répertoire (m a k e dir ectory) « nom_repertoire »

Changer de répertoire¶

Commandes	Utilités
`cd nom_repertoire`	Permet d’aller dans le répertoire « nom_repertoire » (c hange d irectory)
`cd`	Permet d’aller dans son répertoire personnel ($HOME)
`cd ..`	Permet d’aller dans le répertoire parent de notre répertoire actuel
`cd /`	Permet d’aller directement dans le répertoire racine
`cd -`	Permet de retourner dans le répertoire précédent celui dans lequel on était avant d’avoir effectuer l’avant dernière commande « cd »
`cd Mon\Repertoire`	Permet d’aller dans le répertoire « Mon Repertoire » nommé avec un espace

Lister le contenu d’un répertoire¶

Commandes	Utilités
`ls`	Liste (l i s t ) le contenu du répertoire courant
`ls -l`	Liste les informations détaillées (l ong)
`ls -a`	Liste tous (a ll) le contenu du répertoire courant les fichiers cachés ( ceux commançant par un point « . »)
`ls -t`	Trie par date (t ime) à partir des plus récents
`ls -d */`	Liste l’ensemble des répertoire (d irectory)
`ls -S`	Trie par taille (s ize)
`ls nom_repertoire`	Liste les sous répertoires et les fichiers du répertoire « nom_repertoire »
`tree -d`	Liste les répertoires avec leurs arborescences

Copier, déplacer, supprimer - un répertoire¶

Commandes	Utilités
`cp -r rep1 rep2`	C o p ie entièrement (r ecursively) le repértoire « rep1 » dans « rep2 »
`cp -r rep1/rep2`	C o p ie entièrement le contenu du répertoire « rep1 » dans « rep2 »
`rsync -r rep_origine/rep_destination/`	Copie entièrement (r ecursively) le contenu du répertoire « rep_origine » vers « rep_destination »
`mv rep1 rep2`	Déplace (m o v e) le répertoire « rep » s’il est vide
`rm -d rep`	Supprime (r e m ove) le répertoire « rep » s’il est vide
`rm -r rep`	Supprime le répertoire « rep » avec tous son contenu
`rm -rf rep`	Supprime immédiatement (f orce) le répertoire « rep »

Fichiers¶

Afficher le contenu d’un fichier¶

Commandes	Utilités
`cat nom_fichier`	Affiche ( con cat enate) le contenu du fichier « nom_fichier »
`cat -n nom_fichier`	Affiche le contenu du du fichier « nom_fichier » avec les numéros des lignes
`more nom_fichier`	Affiche le contenu du fichier « nom_fichier » page par page
`less nom_fichier`	Affiche le contenu du fichier « nom_fichier avec plus de possibilités
`head -k nom_fichier`	Affiche les k premières lignes du fichier « nom_fichier »
`tail -k nom_fichier`	Affiche les k dernière lignes du fichier « nom_fichier »
`tail -f nom_fichier`	Affiche en continue (f ollow) les dernières lignes du fichier « nom_fichier » celui-ci étant en train d’être écrit
`cat fichier_1 ... fichier_n > fichier`	Concatène les fichier « fichier_1 » … « fichier_n » dans le fichier « fichier »
`cat fichier_1 ... fichier_n >> fichier`	Concatène les fichier « fichier_1 » … « fichier_n » à la suite du fichier « fichier »

Éditer un fichier¶

Pour éditer un fichier on a la commande :
vi fichier

Elle nous permet d’accèder à l’éditeur vi qui fonctionne comme cela :

i¶: Permet d”i nserer du texte avant le curseur
a¶: Permet d”a jouter du texte après le curseur
o¶: Ajoute une ligne après la ligne courante et passe en mode insertion
[ESC]¶: Quitter le mode édition
:w¶: Sauvegarde le fichier (w rite)
:w nom_fichier¶: Sauvegarde le fichier dans « nom_fichier » (w rite)
:q!¶: Quitter sans sauvegarder le fichier (q uit)
:e!¶: Annule tout les changements et revient au fichier original

Édite le fichier « fichier » avec kwrite
kwrite fichier

Crée le fichier « fichier »

touch fichier /////  OU ///// :> fichier

Il existe plusieurs éditeurs de texte disponible : komodo, gedit, geany, nano, emacs, …

Copier, déplacer, supprimer - un fichier¶

Idem que pour un répertoire excepté l’option -r qui est inutile dans le cas d’un fichier

Commandes	Utilités
`cp fichier1 fichier2`	C o p ie entièrement le fichier « fichier1 » dans « fichier2 »
`cp fichier1/fichier2`	C o p ie entièrement le contenu du fichier « fichier1 » dans « fichier2 »
`rsync fichier_origine/fichier_destination/`	Copie entièrement le contenu du fichier « fichier_origine » vers « fichier_destination »
`mv fichier1 fichier2`	Déplace (m o v e) le fichier « fichier » s’il est vide
`rm -d rep`	Supprime (r e m ove) le fichier « fichier » s’il est vide
`rm fichier`	Supprime le fichier « fichier » avec tous son contenu
`rm -f fichier`	Supprime immédiatement (f orce) le fichier « fichier »
`mv file1 file2`	Renomme le fichier « file1 » en « file2 »

Manipulations de fichiers¶

Commandes	Utilités
`awk -F 'print $i' nom_fichier`	Affiche la ième colonne du fichier « nom_fichier » avec la virgule comme séparateur de colonne
`awk 'print $NF' nom_fichier`	Affiche la dernière colonne du fichier « nom_fichier »
`awk 'print NF' nom_fichier`	Nombre de colonnes de chaque ligne du fichier « nom_fichier »
`grep stations nom_fichier`	Affiche les lignes du fichier « nom_fichier » qui contiennent le mot « stations »
`grep -v stations nom_fichier`	Affiche toutes les lignes du fichier « nom_fichier » qui ne contiennent pas le mot « stations »
`wc -l nom_fichier`	Affiche le nombre de lignes contenus dans le fichier « nom_fichier »
`wc -w nom_fichier`	Affiche le nombre de mots contenus dans le fichier « nom_fichier »
`wc -c nom_fichier`	Affiche le nombre de caractères contenus dans le fichier « nom_fichier »
`wc nom_fichier`	(W ord C ount) Affiche le nombre des lignes, de mots et de caractères contenus dans le fichier « nom_fichier »
`sort -n nom_fichier`	Affiche et trie les lignes par ordre alphabétique du fichier « nom_fichier »
`tr -d '\r' <fichier> nouveau_fichier`	Supprime (tr anslate or delete ) les retours chariots (r) du fichier « fichier » et l’écrit dans le fichier « nouveau_fichier » compare les fichiers « fichier1 » et « fichier2 »
`diff fichier1 fichier2`	Compare les fichier « fichier1 » et « fichier2 »
`diff wib fichier1 fichier2`	Compare les fichier « fichier1 » et « fichier2 » mais sans les blanc ni les tabulations
`sdiff -s fichier1 fichier2`	Compare les fichier « fichier1 » et « fichier2 » mais sans les lignes identiques
`tkdiff fichier1 fichier2`	Comparaison graphique des fichier « fichier1 » et « fichier2 »

Les commandes listées ci-dessus possèdent de nombreuses options très puissantes . Il existe également d’autres commandes très intéressantes comme sed, cut, paste, uniq, …

Rechercher des fichiers¶

Commandes	Utilités
`locate nom_fichier`	Localise rapidement (locate) le fichier « nom_fichier » dans toute l’arborescence
`fin /-name sh_gamit -print`	Trouve tous (*) les fichiers se terminant par « .cpp » dans l’arborescence
`find $HOME -name "*.cpp" -print`	À partir de mon répertoire personnel $HOME permet de copier dans « rep_destination » tous (*) les fichiers qui se termine par « .jpg » trouvés à partir du répertoire courant « . »
`find . -iname "*.jpg" -exec cp /rep_destination \ ;`	Permet de supprimer tous (*) les fichiers « .o » auquels on n’a pas accédés depuis plus de 7 jours dans mon répertoire personnel

Liens symboliques¶

Commandes	Utilités
`unlink nom_lien`	Crée le lien symbolique (sym l i n k s) nommé « nom_lien » du fichier « fichier_source »
`ln -s repertoire_source repertoire_lien`	Crée le lien symbolique (sym l i n k s) nommé « repertoire_lien » du répertoire « repertoire_source »
`ln -s fichier_source nom_lien`	Supprime le lien nommé « nom_du_lien »

Archiver / Compresser¶

Archiver, désarchiver - un fichier, un répertoire¶

Commandes	Utilités
`tar -cvzf mon_archive /fichier_a_archiver`	Crée l’archive (t ape ar chive) le fichier « fichier_a_archiver » en « mon_archive.tgz » (pour créer une archive au format .tar.gz il suffit de remplacer le suffixe .tgz par .tar.gz)
`tar -cvzf mon_archive.tgz /rep_a_archiver`	Archive le répertoire « rep_a_archiver » en « mon_archive.tgz »
`tar -xvf archive.tar`	Désarchive l’archive « archive.tar »
`tar -xvzf archive.tgz`	Désarchive et décompresse l’archive compressée « archive.tgz »
`tar -xvzf archive.tar.gz`	Désarchive et décompresse l’archive compressée « archive.tar.gz »
`tar -xvzf archive.tar.bz2`	Désarchive et décompresse l’archive compressée « archive.tar.bz2 »
`tar -tvf archive.tar`	Liste le contenu de l’archive « archive.tar »

Compresser, décompresser un fichier¶

Commandes	Utilités
`gzip run_gamit.c`	Compresse le fichier « run_gamit.c » au format .gz
`gunzip run_gamit.c.gz`	Décompresse le fichier « run_gamit.c.gz »
`compress run_gamit.c`	Compresse le fichier « run_gamit.c » au format .Z
`uncompress run_gamit.c.Z`	Décompresse le fichier « run_gamit.c.Z »
`zip archive.zip fic_1,...,fic_n`	Compresse les fichiers « fic _1,…,fic_n » au format zip en « archive.zip »
`unzip rep.zip -d /rep_destination/.`	Décompresse le fichier « rep.zip » dans le répertoire « /rep_destination »

Processus, applications, mémoire et espace¶

Lorsque l’on exécute une commande ou un programme on crée un processus

Gestion des processus¶

Affiche les taches en cours d’exécution
top
1¶
Pour lister l’ensemble des processeurs

u 'user_name'¶
Pour lister l’ensemble des processus de l’utilisateur « user_name »

M¶
Pour trier les processus par utilisation décroissante de la mémoire

q¶
Pour Quitter

Commandes	Utilités
`ps -ux`	Affiche la liste des processus lancé par l’utilisateur (p rocessus s earch)
`ps -aux`	Affiche la liste des processus lancé par tous les utilisateurs
`ps --forest`	Affiche tous les processus avec leur arborescence
`jobs`	Affiche la liste des processus de l’utilisateur lancé sur la session
`kill -9 numero_proc`	Tue le processus de numéro « numero_proc »
`kill -9 -l`	Tue tous les processus que l’on a le droit de tuer
`killall nom_proc`	Tue tous les processus de nom « nom_proc »

Gestion des applications¶

Commandes	Utilités
`./mon_prog &`	Exécute le programme « mon_prog » en arrière plan grâce au « & »
`fg`	Ramène à l’avant plan un job
`bg`	Relance à l’arrière plan un job endormi
`which nom_commande`	Affiche le chemin absolu de la commande « nom_commande »
`whereis nom_commande`	Recherche les exécutables, sources et page de man de la commande « nom_commande »
`nohup nom_programme`	Exécute le programme « nom_programme » tel qu’il est insensible à la déconnexion

Gestion de la mémoire¶

Commandes	Utilités
`free`	Affiche de l’utilisation de la mémoire RAM et du swap libre
`vmstat n`	Affiche la mémoire virtuelle toute les n seconde

Gestion de l’espace¶

Commandes	Utilités
`df -h`	Affiche la quantité d’espace libre (d isk f ree) sur tous les systèmes de fichiers de façon lisible par l’homme (h uman)
`du -sh nom_repertoire`	Affiche de l’espace disque utilisé (d isk u sage) du répertoire « nom_repertoire »
`du -sh nom_fichier`	Affiche de l’espace disque utilisé (d isk u sage) du fichier « nom_fichier »

Réseau et transfert de données¶

Réseau¶

Commandes	Utilités
`nslookup IP_machine`	Retourne le nom de la machine d’adresse IP « IP_machine »
`nslookup nom_machine`	Retourne l’adress IP de la machine « nom_machine » (n ame s ystem look up)
`ping nom_machine_distante`	Permet de tester si la machine distante « nom_machine_distante » est accesible dans le réseau
`hostname`	Nom de la machine sur laquelle on est connecté

Connexion à une autre machine sur le réseau¶

Permet de se connecter en tant qu’utilisateur « login » à la machine « host_serv » dans ce cas la connexion à la machine distante « host_serv » s’effectue avec le même login
ssh -X login@host_serv ssh host_serv

Transfer de données entre deux machines Linux¶

Commandes	Utilités
`scp - r rep_orig host_serv_dist :/rep_dest`	Permet de copié et de sécuriser (s ecure c o p ie) du répertoire « rep_orig » de ma machine locale vers ma machine distante « host_ser_dist » dans le répertoire « rep_dest »
`rsync -arvuzH --progress --size-only rep_orig host_serv_dist :/rep_dest`	Permet de synchroniser à distante (r emote sync hronize) le répertoire « rep_orig » de ma machine locale vers ma machine distante « host_serv_dist » avec le répertoire « rep_dest »
`ftp server_name`	Permet de se connecter via FTP à la machine distante « server_name »
`prompt of`	Permet de désactiver l’inter-activité sur les commandes suivantes
`mget*.gz`	Permet de récupérer tous(*) les fichiers au format gz

Transfert de données entre une machine Linux et Windows¶

Il existe plusieurs outils disponibles gratuitement : winscp, filezila, samba

Gestion du temps¶

Exécution planifier de programmes¶

Cron est un démon qui permet d’exécuter la liste des programmes spécifiés à un temps donné renseignés dans le fichier « crontab ». (daemon : d isk a nd e xecution mon itor est un programme qui réalise des taches de fond du système)

Commandes	Utilités
`crontab -e`	Édite la crontab
`crontab -l`	Affiche la crontab actuelle
`crontab -r`	Supprime la crontab

Le fichier « crontab » :

mm hh dom mon dow     command

avec :

mm¶: minutes ∈ [0;59]
hh¶: heures ∈ [0;23]
dom¶: jours du mois (d ay o f m onth) ∈ [1;31]
mon¶: mois (mon th) ∈ [1;12]
dow¶: jour de la semaine (d ay o f w eek ∈ [0;6] avec 0 pour dimanche
command¶: commande , script , code à exécuter

Exemple d’un script qui se lance tous les jours à 4h00:

00 04 * * * /date/fred/Functions/backups

Commandes relatives au temps¶

Commandes	Utilités
`date`	Affiche la date et l’heure
`time ./mon_prog`	Mesure le temps pris par l’exécution du script « mon_prog »
`sleep 20`	Attendre 20 secondes
`cal`	Calendrier du mois en cours
`cal 1 2014`	Calendrier du mois de janvier de l’année 2014

Shell¶

Le Shell est l’interpréteur de commande ce qui signifie qu’il est l’interface entre l’utilisateur et le système d’exploitation.

Autrement dit c’est un langage de programmation qui permet de lire et d’exécuter les commandes ou les scripts saisies dans le console.

Il existe différent shells : sh (Bourne Shell), bash (Bourne Again Shell), csh (C Shell), Tcsh (Tenex C Shell), ksh (Korn Shell) et zsh (Zero Shell).

Chaque utilisateur possède un shell par défaut lancé à l’ouverture d’une invite de commande.

Le shell par défaut est précisé dans le fichier de configuration /etc/passwd dans le dernier champ de la ligne correspondant à l’utilisateur. Le shell s’initialise en lisant sa configuration globale (dans un fichier du répertoire /etc), puis en lisant la configuration propre à l’utilisateur (dans un fichier caché, dont le nom commence par un point, situé dans le répertoire personnel de l’utilisateur (/home/nom_utilisateur/.fichier_de_configuration).

Shell de connexion¶

Commandes	Utilités
`echo $SHELL`	Nom de mon shell de connexion
`grep $USER /etc/passwd`	Nom de mon shell de connexion avec plus d’informations
`.bashrc`	Fichier d’initialisation du shell bash par défaut
`nom_nouveau_shell`	Permet de changer son shell courant par le shell nom_nouveau_shell
`alial cl='clear'`	Definit l’alias (raccourci) cl de la commande clear pour les shells : sh, bash, ksh et zsh
`alial cl 'clear'`	Definit l’alias (raccourci) cl de la commande clear pour les shells : csh et tcsh
`exit`	Arrête l’exécution du shell

Variables d’environnement¶

SHELL¶: Shell utilisé (sh, bash, ksh, …)
USER¶: Nom d’utilisateur sous lequel on est connecté
HOME¶: Poisition de votre répertoire personnel
PATH¶: Liste des répertoires qui contiennent des exécutables que vous souhaitez lancer sans indiquer leur répertoire
PWD¶: Le répertoire dans lequel vous vous trouvez
HOSTNAME¶: Nom de la machine
LD_LIBRARY_PATH¶: Ensemble des répertoires dans lesquels sont stockées les bibliothèqyes dynamiques

Connaître, utiliser, définir, supprimer - une(des) variable(s) d’environnement¶

Commandes	Utilités
`env` / `printenv`	Liste toutes les variables d’environnement définies en mémoire
`set`	Liste toutes les variables locales définies en mémoire
`echo $NOM_VARIABLE`	Affiche la variable d’environnement définie par « $NOM_VARIABLE »
`set NOM_VARIABLE`	Définie la varianle d’environnement « NOM_VARIABLE »
`export NOM_VARIABLE`	Exporte la variable « NOM_VARIABLE » de manière globale tel qu’elle soit connue de tous les sous-shells valable pour les shells : sh, bash, ksh et zsh
`setenv NOM_VARIABLE`	Exporte la variable « NOM_VARIABLE » de manière globale tel qu’elle soit connue de tous les sous-shells valable pour les C shells : csh et tcsh
`unset NOM_VARIABLE`	Supprime la variable « NOM_VARIABLE »

Script shell¶

SHELL¶: Shell utilisé (sh, bash, ksh, …)
USER¶: Nom d’utilisateur sous lequel on est connecté
HOME¶: Poisition de votre répertoire personnel

Un script shell permet d’automatiser une série d’opérations. C’est tout simplement un fichier écrit en langage shell, contenant plusieurs commandes qui seront exécutées de manière séquentielle.

La première chose à faire pour écrire un script shell est d’indiquer l’emplacement dans l’arborescence du shell que l’on va utiliser précédé des deux caractère #! (le shebang).

Par exemple pour un script écrit en ksh la première ligne est : #!/bin/ksh

Pour exécuter notre script deux possibilités :

Commandes	Utilités
`./nom_du_script`	Exécute le script « nom_du_script » s’il est exécutable
`chmod u+x nom_du_script`	Si le script n’est pas exécutable il faut le rendre exécutable via
`/nom_du_shell_utilisé nom_du_script`	Exécute le script « nom_du_script » avec le shell à partir du quel il est écrit (on invoque l’interpréteur qui lui correspond)

Variables - arguments¶

Commandes	Utilités
`ma_variable=valeur`	Affecte « valeur » à la variable « ma_variable » valable pour les shells : sh, bash, ksh
`et ma_variable = valeur`	Affecte « valeur » à la variable « ma_variable » valable pour les C shells : csh et tcsh
`$ma_variable` / `${ma_variable}`	Contenu de la variable « ma_variable » »
`$0`	Nom du script exécuté
`$i`	Ième paramètre avec 1≤ i ≤9
`$?`	Code erreur de retour de la dernière commande (0 : vrai ; sinon faux )
`$@` / `$*`	Tous les paramètres
`$#`	Nombre de paramètres

Flux standard¶

Lors de l’exécution d’une commande, un processus est créé. Celui-ci va alors ouvrir trois flux :

stdin¶: Entrée standard (st an d ard in put), dans lequel le processus va lire les données d’entrée. Par défaut stdin correspond au clavier il est identifié par le numéro 0
stdout¶: Sortie standard (st an d ard out put), dans lequel le processus va écrire les données de sortie. Par défaut stdout correspond à l’écran ; il est identifié par le numéro 1
stderr¶: Erreur standard (st an d ard err or), dans lequel le processus va écrire les messages d’erreur. Par defaut stderr correspond à l’écran ; il est identifié par le numéro 2

Flux de redirection¶

Par défaut lorque l’on exécute un programme, les données sont 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…

Ici commande désigne aussi bien une commande, une combinaison de commande ou l’exécution d’un script ou d’un code.

Commandes	Utilités
`commande > output`	Redirection de la sortie standard de la commande « commande » vers le fichier « output » ; si ce fichier n’existe pas alors il est créé, sinon il est écrasé
`commande >> output`	Redirection de sortie standard vers le fichier « output » ; si ce fichier n’existe pas alors il est créé , sinon les données sont ajoutées à la fin du fichier existant
`commande < input`	Redirection de l’entrée standard vers le fichier « input »
`commande << mot`	Redirection de l’entrée standard jusqu’à la première occurrence du mot « mot »
`2 > output`	Redirection de l’erreur standard vers le fichier « output »

Exemples de scripts en ksh¶

Un script de sauvegarde :

Listing 1 - bash version¶

        # !/ bin / ksh
        #------------------------------------------------------------------------
        # backups : synchronise mes repertoires definies dans le tableau
        # " repertoires " de ma machine locale vers ma machine distante " magellan "
        # ------------------------------------------------------------------------
        # --- declaration des variables ---
        reps = ' Functions Gravi Programmation Troposphere '
        # --- programme principal ---
        for rep in $reps
        do
        rsync - avuzH -- progress -- size - only -- delete ~/ $rep / magellan :~/ $rep /
        done
        # --- sortie du script ---
        exit 0

Idem mais avec une autre syntaxe

Listing 2 - bash version¶

        # !/ bin / ksh
        # ------------------------------------------------------------------------
        # backups : syn hronise mes repertoires definies dans le tableau
        # " repertoires " de ma machine locale vers ma machine distante " magellan "
        # ------------------------------------------------------------------------
        # --- declaration des variables ---
        set -A repertoires $HOME / Functions $HOME / Gravi $HOME / Programmation \
        $HOME / Troposphere
        # --- programme principal ---
        for (( i =0; i < $ { # repertoires [*℄}; i ++))
        do
        rsync - avuzH -- progress -- size - only -- delete \
        $ { repertoires [ $i ℄}/ magellan : $ { repertoires [ $i ℄}/
        done
        # --- sortie du script ---
        exit 0

Un script de temps de calcul des décimales de pi

Listing 3 - bash version¶

        # !/ bin / ksh
        # ------------------------------------------------------------------------
        # benchPi : retourne le temps de calcul du nombre de decimales de pi
        #            donnees en argument
        # ------------------------------------------------------------------------
        # --- declaration des variables ---
        DIRWORK = $HOME / Pi / pi - test
        output = " $DIRWORK / out_pi_galilee "
        # --- programme principal ---
        i =0
        while [ i - lt 10 ℄
        do echo " --- $0 $1
        run $i --- "
        ./ pi_ ss5 $1 > $DIRWORK / pi_$i 2 >/ dev / null
        temps = ` grep real $DIRWORK / pi_$i | cut - 1 -6 `
        echo $temps  $out
        echo " --- ./ pi_run$i : $temps ---"
        rm -f $DIRWORK / pi_$i
        i = $ (( $i + 1))
        done
        # --- suppression des fichiers temporaires ---
        rm - fv $DIRWORK /*~ pi *. txt
        exit 0

Compilation¶

Contrairement aux langages interprétés , les langages compilés nécessitent une phase supplémentaire mais indispensable entre l’écriture du code source et son exécution : la compilation réalisée par un compilateur. Ce dernier traduit le code source en un exécutable directement compréhensible par les processeurs

C, C++¶

Commandes	Utilités
`gcc mon_prog.c -o mon_exe`	Compilation C du fichier « mon_prog.c » et création de l’exécutable « mon_exe »
`gcc mon_prog.c -o mon_exe -std=c99 -lm`	Compilation C du fichier « mon_prog.c » et création de l’exécutable « mon_exe » avec les options de recherche de fonctions dans la librairie mathématique
`g++ mon_prog.cpp -o mon_exe`	Compilation C++ du fichier « mon_prog.c » et création de l’exécutable « mon_exe »

Fortran¶

Commandes	Utilités
`gfortran mon_prog.f -0 mon_exe -ffree-form -Wall`	Compilation Fortran du fichier « mon_prog.f » et création de l’exécutable « mon_exe » avec les options
`gfortran mon_prog.f -o mon_exe`	Compilation Fortran du fichier « mon_prog.f » et création de l’exécutable « mon_exe »

Librairie¶

Commandes	Utilités
`ar crv ma_lib.a mon_exe.o`	Range l’exécutable « mon_exe.o » dans ma librairie personnelle « ma_lib.a »
`ar -t ma_lib.a`	Liste les fichiers objets dans la librairie « ma_lib.a »
`ldd mon_exe`	Liste les librairies partagées appelées par mon programme exécutable « mon_exe »

Makefile et make¶

La réalisation d’un projet nécessite la compilation en général de nombreux fichiers source en fichiers objet, puis l’édition de liens pour générer un fichier exécutable. Cela s’effectue via l’intermédiaire d’un fichier et d’une commande :

Le makefile est un fichier qui sert à définir toutes les directives de compilation du projet à partir d’un ensemble de règles
La commande make permet d’exécuter l’ensemble des commandes spécifiées dans le makefile .

En soi make est bien plus qu’une commande , make possède de nombreuses subtilités et possibilités …