.. include:: special.rst
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
-------------------------
.. glossary ::
``/``
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``
-----------------------------------
.. glossary ::
``/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``
-----------------------------------
.. glossary ::
``/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, ...
.. list-table::
* - Commandes
- Utilités
* - :code:`man nom_commande` / :code:`nom_commande -help`
- Accède au manuel de la commande "nom_commande"
* - :code:`clear`
- Nettoie l'écran de la console
* - :code:`reset`
- Permet de rétablir la console
* - :code:`history`
- Affiche l'historique des commandes tapées
* - :code:`!numéro_ligne_historique`
- Exécute la commande correpsondante à la ligne "numéro_ligne_historique" de l'historique quitte la console
* - :code:`exit`
- Quitte la console
* - :code:`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
* - :code:`commande1 & commande2`
- Les deux commandes "commande1" et "commande2" sont exécutées simultanément avec "commande1" exécutée en arrière plan
* - :code:`commande1 && commande2`
- Exécute les commandes "commande1" et "commande2" uniquement si la "commande1" est réussi .
* - :code:`commande1 || commande2`
- La commande "commande2" s'exécute seulement si la "commande1" échoue
* - :code:`commande1 ; commande2`
- Les deux commandes "commande1" et "commande2" sont exécutées dans l'ordre
Quelques raccourcis claviers en mode console
--------------------------------------------
.. glossary ::
``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
------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`whoami`
- Affiche mon nom d'utilisateur
* - :code:`hostname`
- Nom de la machine sur laquelle on est connecté
* - :code:`uname -a`
- Affiche les informations sur la version Linux installé
* - :code:`w`
- Affiche les informations de connexions des différents utilisateurs
* - :code:`who` / :code:`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 :
.. glossary ::
``-``
Fichier
``d``
Répertoire (:red:`d` irectory)
``l``
Lien (:red:`l` ink)
Les 9 autres caractères sont regroupés en 3 identités : l':red:`u` tilisateur , le :red:`g` roupe et les autres (:red:`o` ther).
Sur chaque identité on a l'information sur les droits d'accès suivants :
.. glossary ::
``r``
Lecture (:red:`r` ead)
``w``
Write (:red:`w` rite)
``x``
Exécution(e :red:`x` ecute)
Pour pouvoir modifier ou consulter les droits d'accès on utilise ces commandes :
.. list-table::
* - Commandes
- Utilités
* - :code:`ls -l`
- Affiche les droits des objets contenus
* - :code:`chmod u+x mon_script`
- Donne (:red:`+`) le droit (:red:`ch` ange :red:`mod` e) d'e :red:`x` écution à l':red:`u` tilisateur du fichier "mon_script"
* - :code:`chmod o-w mon_script`
- Supprime le droit (:red:`-`) d'écritture (:red:`w` rite) aux autres (:red:`o` ther) utilisateurs que le propriétaire actuel du fichier "mon_script" et ceux qui font partie du groupe .
* - :code:`chmod -R ug+w,o-r mon_repertoire`
- Donne (:red:`+`) les droits d'écriture (:red:`w`) au propriétaire (:red:`u` ser) et au :red:`g` roupe de manière récursive (:red:`-R`) du répertoire "mon_repertoire" mais aussi (:red:`,`) supprime (:red:`-`) le droit de lecture (:red:`r`) aux autres utilisateurs (:red:`o` ther) de ce répertoire .
Les commandes chmod sont aussi réalisable en numériques .
Répertoires
===========
Se positioner dans l'arboresence
--------------------------------
.. glossary ::
``pwd``
Affiche mon répertoire courant (:red:`p` rint :red:`w` ork :red:`d` irectory)
``.``
Accès au répertoire courant
``..``
Accès au répertoire parent
Chemin absolu, relatif
----------------------
Le :red:`chemin absolu` contient l'arborescence complète en partant de la racine.
Le :red:`chemin relatif` contient l'arborescence à partir du répertoire courant.
Créer un répertoire
-------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`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éé
* - :code:`mkdir rep1/rep2`
- Crée le répertoire (:red:`m` a :red:`k` e :red:`dir` ectory) "nom_repertoire"
Changer de répertoire
---------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`cd nom_repertoire`
- Permet d'aller dans le répertoire "nom_repertoire" (:red:`c` hange :red:`d` irectory)
* - :code:`cd`
- Permet d'aller dans son répertoire personnel ($HOME)
* - :code:`cd ..`
- Permet d'aller dans le répertoire parent de notre répertoire actuel
* - :code:`cd /`
- Permet d'aller directement dans le répertoire racine
* - :code:`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"
* - :code:`cd Mon\Repertoire`
- Permet d'aller dans le répertoire "Mon Repertoire" nommé avec un espace
Lister le contenu d'un répertoire
---------------------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`ls`
- Liste (:red:`l` i :red:`s` t ) le contenu du répertoire courant
* - :code:`ls -l`
- Liste les informations détaillées (:red:`l` ong)
* - :code:`ls -a`
- Liste tous (:red:`a` ll) le contenu du répertoire courant les fichiers cachés ( ceux commançant par un point ":red:`.`")
* - :code:`ls -t`
- Trie par date (:red:`t` ime) à partir des plus récents
* - :code:`ls -d */`
- Liste l'ensemble des répertoire (:red:`d` irectory)
* - :code:`ls -S`
- Trie par taille (:red:`s` ize)
* - :code:`ls nom_repertoire`
- Liste les sous répertoires et les fichiers du répertoire "nom_repertoire"
* - :code:`tree -d`
- Liste les répertoires avec leurs arborescences
Copier, déplacer, supprimer - un répertoire
-------------------------------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`cp -r rep1 rep2`
- :red:`C` o :red:`p` ie entièrement (:red:`r` ecursively) le repértoire "rep1" dans "rep2"
* - :code:`cp -r rep1/rep2`
- :red:`C` o :red:`p` ie entièrement le contenu du répertoire "rep1" dans "rep2"
* - :code:`rsync -r rep_origine/rep_destination/`
- Copie entièrement (:red:`r` ecursively) le contenu du répertoire "rep_origine" vers "rep_destination"
* - :code:`mv rep1 rep2`
- Déplace (:red:`m` o :red:`v` e) le répertoire "rep" s'il est vide
* - :code:`rm -d rep`
- Supprime (:red:`r` e :red:`m` ove) le répertoire "rep" s'il est vide
* - :code:`rm -r rep`
- Supprime le répertoire "rep" avec tous son contenu
* - :code:`rm -rf rep`
- Supprime immédiatement (:red:`f` orce) le répertoire "rep"
Fichiers
========
Afficher le contenu d'un fichier
--------------------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`cat nom_fichier`
- Affiche ( con :red:`cat` enate) le contenu du fichier "nom_fichier"
* - :code:`cat -n nom_fichier`
- Affiche le contenu du du fichier "nom_fichier" avec les numéros des lignes
* - :code:`more nom_fichier`
- Affiche le contenu du fichier "nom_fichier" page par page
* - :code:`less nom_fichier`
- Affiche le contenu du fichier "nom_fichier avec plus de possibilités
* - :code:`head -k nom_fichier`
- Affiche les k premières lignes du fichier "nom_fichier"
* - :code:`tail -k nom_fichier`
- Affiche les k dernière lignes du fichier "nom_fichier"
* - :code:`tail -f nom_fichier`
- Affiche en continue (:red:`f` ollow) les dernières lignes du fichier "nom_fichier" celui-ci étant en train d'être écrit
* - :code:`cat fichier_1 ... fichier_n > fichier`
- Concatène les fichier "fichier_1" ... "fichier_n" dans le fichier "fichier"
* - :code:`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 :
.. code :: python
vi fichier
Elle nous permet d'accèder à l'éditeur vi qui fonctionne comme cela :
.. glossary ::
``i``
Permet d':red:`i` nserer du texte avant le curseur
``a``
Permet d':red:`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 (:red:`w` rite)
``:w nom_fichier``
Sauvegarde le fichier dans "nom_fichier" (:red:`w` rite)
``:q!``
Quitter sans sauvegarder le fichier (:red:`q` uit)
``:e!``
Annule tout les changements et revient au fichier original
- Édite le fichier "fichier" avec kwrite
.. code :: python
kwrite fichier
- Crée le fichier "fichier"
.. code :: python
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
.. list-table::
* - Commandes
- Utilités
* - :code:`cp fichier1 fichier2`
- :red:`C` o :red:`p` ie entièrement le fichier "fichier1" dans "fichier2"
* - :code:`cp fichier1/fichier2`
- :red:`C` o :red:`p` ie entièrement le contenu du fichier "fichier1" dans "fichier2"
* - :code:`rsync fichier_origine/fichier_destination/`
- Copie entièrement le contenu du fichier "fichier_origine" vers "fichier_destination"
* - :code:`mv fichier1 fichier2`
- Déplace (:red:`m` o :red:`v` e) le fichier "fichier" s'il est vide
* - :code:`rm -d rep`
- Supprime (:red:`r` e :red:`m` ove) le fichier "fichier" s'il est vide
* - :code:`rm fichier`
- Supprime le fichier "fichier" avec tous son contenu
* - :code:`rm -f fichier`
- Supprime immédiatement (:red:`f` orce) le fichier "fichier"
* - :code:`mv file1 file2`
- Renomme le fichier "file1" en "file2"
Manipulations de fichiers
-------------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`awk -F 'print $i' nom_fichier`
- Affiche la ième colonne du fichier "nom_fichier" avec la virgule comme séparateur de colonne
* - :code:`awk 'print $NF' nom_fichier`
- Affiche la dernière colonne du fichier "nom_fichier"
* - :code:`awk 'print NF' nom_fichier`
- Nombre de colonnes de chaque ligne du fichier "nom_fichier"
* - :code:`grep stations nom_fichier`
- Affiche les lignes du fichier "nom_fichier" qui contiennent le mot "stations"
* - :code:`grep -v stations nom_fichier`
- Affiche toutes les lignes du fichier "nom_fichier" qui ne contiennent pas le mot "stations"
* - :code:`wc -l nom_fichier`
- Affiche le nombre de lignes contenus dans le fichier "nom_fichier"
* - :code:`wc -w nom_fichier`
- Affiche le nombre de mots contenus dans le fichier "nom_fichier"
* - :code:`wc -c nom_fichier`
- Affiche le nombre de caractères contenus dans le fichier "nom_fichier"
* - :code:`wc nom_fichier`
- (:red:`W` ord :red:`C` ount) Affiche le nombre des lignes, de mots et de caractères contenus dans le fichier "nom_fichier"
* - :code:`sort -n nom_fichier`
- Affiche et trie les lignes par ordre alphabétique du fichier "nom_fichier"
* - :code:`tr -d '\r' <fichier> nouveau_fichier`
- Supprime (:red:`tr` anslate or delete ) les retours chariots (:red:`\r`) du fichier "fichier" et l'écrit dans le fichier "nouveau_fichier" compare les fichiers "fichier1" et "fichier2"
* - :code:`diff fichier1 fichier2`
- Compare les fichier "fichier1" et "fichier2"
* - :code:`diff wib fichier1 fichier2`
- Compare les fichier "fichier1" et "fichier2" mais sans les blanc ni les tabulations
* - :code:`sdiff -s fichier1 fichier2`
- Compare les fichier "fichier1" et "fichier2" mais sans les lignes identiques
* - :code:`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
-----------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`locate nom_fichier`
- Localise rapidement (:red:`locate`) le fichier "nom_fichier" dans toute l'arborescence
* - :code:`fin /-name sh_gamit -print`
- Trouve tous (:red:`*`) les fichiers se terminant par ".cpp" dans l'arborescence
* - :code:`find $HOME -name "*.cpp" -print`
- À partir de mon répertoire personnel :red:`$HOME` permet de copier dans "rep_destination" tous (:red:`*`) les fichiers qui se termine par ".jpg" trouvés à partir du répertoire courant ":red:`.`"
* - :code:`find . -iname "*.jpg" -exec cp /rep_destination \ ;`
- Permet de supprimer tous (:red:`*`) les fichiers ".o" auquels on n'a pas accédés depuis plus de 7 jours dans mon répertoire personnel
Liens symboliques
-----------------
.. list-table::
* - Commandes
- Utilités
* - :code:`unlink nom_lien`
- Crée le lien symbolique (sym :red:`l` i :red:`n` k :red:`s`) nommé "nom_lien" du fichier "fichier_source"
* - :code:`ln -s repertoire_source repertoire_lien`
- Crée le lien symbolique (sym :red:`l` i :red:`n` k :red:`s`) nommé "repertoire_lien" du répertoire "repertoire_source"
* - :code:`ln -s fichier_source nom_lien`
- Supprime le lien nommé "nom_du_lien"
Archiver / Compresser
=====================
Archiver, désarchiver - un fichier, un répertoire
-------------------------------------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`tar -cvzf mon_archive /fichier_a_archiver`
- Crée l'archive (:red:`t` ape :red:`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)
* - :code:`tar -cvzf mon_archive.tgz /rep_a_archiver`
- Archive le répertoire "rep_a_archiver" en "mon_archive.tgz"
* - :code:`tar -xvf archive.tar`
- Désarchive l'archive "archive.tar"
* - :code:`tar -xvzf archive.tgz`
- Désarchive et décompresse l'archive compressée "archive.tgz"
* - :code:`tar -xvzf archive.tar.gz`
- Désarchive et décompresse l'archive compressée "archive.tar.gz"
* - :code:`tar -xvzf archive.tar.bz2`
- Désarchive et décompresse l'archive compressée "archive.tar.bz2"
* - :code:`tar -tvf archive.tar`
- Liste le contenu de l'archive "archive.tar"
Compresser, décompresser un fichier
-----------------------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`gzip run_gamit.c`
- Compresse le fichier "run_gamit.c" au format .gz
* - :code:`gunzip run_gamit.c.gz`
- Décompresse le fichier "run_gamit.c.gz"
* - :code:`compress run_gamit.c`
- Compresse le fichier "run_gamit.c" au format .Z
* - :code:`uncompress run_gamit.c.Z`
- Décompresse le fichier "run_gamit.c.Z"
* - :code:`zip archive.zip fic_1,...,fic_n`
- Compresse les fichiers "fic _1,...,fic_n" au format zip en "archive.zip"
* - :code:`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
.. code :: python
top
.. glossary ::
``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
.. list-table::
* - Commandes
- Utilités
* - :code:`ps -ux`
- Affiche la liste des processus lancé par l'utilisateur (:red:`p` rocessus :red:`s` earch)
* - :code:`ps -aux`
- Affiche la liste des processus lancé par tous les utilisateurs
* - :code:`ps --forest`
- Affiche tous les processus avec leur arborescence
* - :code:`jobs`
- Affiche la liste des processus de l'utilisateur lancé sur la session
* - :code:`kill -9 numero_proc`
- Tue le processus de numéro "numero_proc"
* - :code:`kill -9 -l`
- Tue tous les processus que l'on a le droit de tuer
* - :code:`killall nom_proc`
- Tue tous les processus de nom "nom_proc"
Gestion des applications
------------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`./mon_prog &`
- Exécute le programme "mon_prog" en arrière plan grâce au ":red:`&`"
* - :code:`fg`
- Ramène à l'avant plan un job
* - :code:`bg`
- Relance à l'arrière plan un job endormi
* - :code:`which nom_commande`
- Affiche le chemin absolu de la commande "nom_commande"
* - :code:`whereis nom_commande`
- Recherche les exécutables, sources et page de man de la commande "nom_commande"
* - :code:`nohup nom_programme`
- Exécute le programme "nom_programme" tel qu'il est insensible à la déconnexion
Gestion de la mémoire
---------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`free`
- Affiche de l'utilisation de la mémoire RAM et du swap libre
* - :code:`vmstat n`
- Affiche la mémoire virtuelle toute les n seconde
Gestion de l'espace
-------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`df -h`
- Affiche la quantité d'espace libre (:red:`d` isk :red:`f` ree) sur tous les systèmes de fichiers de façon lisible par l'homme (:red:`h` uman)
* - :code:`du -sh nom_repertoire`
- Affiche de l'espace disque utilisé (:red:`d` isk :red:`u` sage) du répertoire "nom_repertoire"
* - :code:`du -sh nom_fichier`
- Affiche de l'espace disque utilisé (:red:`d` isk :red:`u` sage) du fichier "nom_fichier"
Réseau et transfert de données
==============================
Réseau
------
.. list-table::
* - Commandes
- Utilités
* - :code:`nslookup IP_machine`
- Retourne le nom de la machine d'adresse IP "IP_machine"
* - :code:`nslookup nom_machine`
- Retourne l'adress IP de la machine "nom_machine" (:red:`n` ame :red:`s` ystem :red:`look up`)
* - :code:`ping nom_machine_distante`
- Permet de tester si la machine distante "nom_machine_distante" est accesible dans le réseau
* - :code:`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
.. code :: python
ssh -X login@host_serv
ssh host_serv
Transfer de données entre deux machines Linux
---------------------------------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`scp - r rep_orig host_serv_dist :/rep_dest`
- Permet de copié et de sécuriser (:red:`s` ecure :red:`c` o :red:`p` ie) du répertoire "rep_orig" de ma machine locale vers ma machine distante "host_ser_dist" dans le répertoire "rep_dest"
* - :code:`rsync -arvuzH --progress --size-only rep_orig host_serv_dist :/rep_dest`
- Permet de synchroniser à distante (:red:`r` emote :red:`sync` hronize) le répertoire "rep_orig" de ma machine locale vers ma machine distante "host_serv_dist" avec le répertoire "rep_dest"
* - :code:`ftp server_name`
- Permet de se connecter via FTP à la machine distante "server_name"
* - :code:`prompt of`
- Permet de désactiver l'inter-activité sur les commandes suivantes
* - :code:`mget*.gz`
- Permet de récupérer tous(:red:`*`) 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 : :red:`d` isk :red:`a` nd :red:`e` xecution :red:`mon` itor est un programme qui réalise des taches de fond du système)
.. list-table::
* - Commandes
- Utilités
* - :code:`crontab -e`
- Édite la crontab
* - :code:`crontab -l`
- Affiche la crontab actuelle
* - :code:`crontab -r`
- Supprime la crontab
Le fichier "crontab" :
.. code :: python
mm hh dom mon dow command
avec :
.. glossary ::
``mm``
minutes ∈ [0;59]
``hh``
heures ∈ [0;23]
``dom``
jours du mois (:red:`d` ay :red:`o` f :red:`m` onth) ∈ [1;31]
``mon``
mois (:red:`mon` th) ∈ [1;12]
``dow``
jour de la semaine (:red:`d` ay :red:`o` f :red:`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:
.. code :: python
00 04 * * * /date/fred/Functions/backups
Commandes relatives au temps
----------------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`date`
- Affiche la date et l'heure
* - :code:`time ./mon_prog`
- Mesure le temps pris par l'exécution du script "mon_prog"
* - :code:`sleep 20`
- Attendre 20 secondes
* - :code:`cal`
- Calendrier du mois en cours
* - :code:`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
------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`echo $SHELL`
- Nom de mon shell de connexion
* - :code:`grep $USER /etc/passwd`
- Nom de mon shell de connexion avec plus d'informations
* - :code:`.bashrc`
- Fichier d'initialisation du shell bash par défaut
* - :code:`nom_nouveau_shell`
- Permet de changer son shell courant par le shell nom_nouveau_shell
* - :code:`alial cl='clear'`
- Definit l'alias (raccourci) cl de la commande clear pour les shells : sh, bash, ksh et zsh
* - :code:`alial cl 'clear'`
- Definit l'alias (raccourci) cl de la commande clear pour les shells : csh et tcsh
* - :code:`exit`
- Arrête l'exécution du shell
Variables d'environnement
-------------------------
.. glossary ::
``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
------------------------------------------------------------------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`env` / :code:`printenv`
- Liste toutes les variables d'environnement définies en mémoire
* - :code:`set`
- Liste toutes les variables locales définies en mémoire
* - :code:`echo $NOM_VARIABLE`
- Affiche la variable d'environnement définie par "$NOM_VARIABLE"
* - :code:`set NOM_VARIABLE`
- Définie la varianle d'environnement "NOM_VARIABLE"
* - :code:`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
* - :code:`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
* - :code:`unset NOM_VARIABLE`
- Supprime la variable "NOM_VARIABLE"
Script shell
============
.. glossary ::
``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 :red:`#!` (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 :
.. list-table::
* - Commandes
- Utilités
* - :code:`./nom_du_script`
- Exécute le script "nom_du_script" s'il est exécutable
* - :code:`chmod u+x nom_du_script`
- Si le script n'est pas exécutable il faut le rendre exécutable via
* - :code:`/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
---------------------
.. list-table::
* - Commandes
- Utilités
* - :code:`ma_variable=valeur`
- Affecte "valeur" à la variable "ma_variable" valable pour les shells : sh, bash, ksh
* - :code:`et ma_variable = valeur`
- Affecte "valeur" à la variable "ma_variable" valable pour les C shells : csh et tcsh
* - :code:`$ma_variable` / :code:`${ma_variable}`
- Contenu de la variable "ma_variable""
* - :code:`$0`
- Nom du script exécuté
* - :code:`$i`
- Ième paramètre avec 1≤ i ≤9
* - :code:`$?`
- Code erreur de retour de la dernière commande (0 : vrai ; sinon faux )
* - :code:`$@` / :code:`$*`
- Tous les paramètres
* - :code:`$#`
- 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 :
.. glossary ::
``stdin``
Entrée standard (:red:`st` an :red:`d` ard :red:`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 :red:`0`
``stdout``
Sortie standard (:red:`st` an :red:`d` ard :red:`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 :red:`1`
``stderr``
Erreur standard (:red:`st` an :red:`d` ard :red:`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 :red:`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.
.. list-table::
* - Commandes
- Utilités
* - :code:`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é
* - :code:`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
* - :code:`commande < input`
- Redirection de l'entrée standard vers le fichier "input"
* - :code:`commande << mot`
- Redirection de l'entrée standard jusqu'à la première occurrence du mot "mot"
* - :code:`2 > output`
- Redirection de l'erreur standard vers le fichier "output"
Exemples de scripts en ksh
--------------------------
Un script de sauvegarde :
.. code-block :: bash
:caption: 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
.. code-block :: bash
:caption: 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
.. code-block :: bash
:caption: 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++
------
.. list-table::
* - Commandes
- Utilités
* - :code:`gcc mon_prog.c -o mon_exe`
- Compilation C du fichier "mon_prog.c" et création de l'exécutable "mon_exe"
* - :code:`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
* - :code:`g++ mon_prog.cpp -o mon_exe`
- Compilation C++ du fichier "mon_prog.c" et création de l'exécutable "mon_exe"
Fortran
-------
.. list-table::
* - Commandes
- Utilités
* - :code:`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
* - :code:`gfortran mon_prog.f -o mon_exe`
- Compilation Fortran du fichier "mon_prog.f" et création de l'exécutable "mon_exe"
Librairie
---------
.. list-table::
* - Commandes
- Utilités
* - :code:`ar crv ma_lib.a mon_exe.o`
- Range l'exécutable "mon_exe.o" dans ma librairie personnelle "ma_lib.a"
* - :code:`ar -t ma_lib.a`
- Liste les fichiers objets dans la librairie "ma_lib.a"
* - :code:`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 :
1. Le ``makefile`` est un fichier qui sert à définir toutes les directives de compilation du projet à partir d'un ensemble de règles
2. 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 ...