Source : Pirate Informatique n°36 (Étienne Sellan)

Noeud Tor : Apportez votre pierre à l’édifice.
Tor est l’un des outils d’anonymat les plus populaires et l’un des réseaux les plus développés. Il a l’avantage en plus d’être fonctionnel dès son installation et de vous rendre anonyme sur la toile dès son lancement. Mais l’oignon ne tourne pas tout seul, il s’appuie sur des milliers de bénévoles qui partagent un peu de leur bande passante au service de la vie privée. Pour cela, ils font tourner un « nœud Tor » sur leur machine….

Tor est un protocole permettant de rester anonyme sur Internet et d’accéder à des sites cachés. Il est supporté par une grosse communauté de développeurs qui contribuent à le rendre impénétrable, mais aussi à la doter de divers services annexes : e-mail, messageries, partage de fichiers, ect. Les paquets de données transitent d’un routeur vers un autre en laissant peu de traces sur leur origine. Mais saviez-vous que ces « relais » étaient gérés par des bénévoles et que vous pouviez en faire partie ?

Qu’est-ce qu’un Nœud ? 
Un nœud Tor (ou relais Tor) est un ordinateur qui sert de relais pour les connexions des utilisateurs du protocole Tor. Il en existe 3 types. Les « entry guards » sont les nœuds d’entrée : c’est le premier relais auquel va se connecter l’utilisateur. Les « middle relays » sont les nœuds du milieu de la chaîne, ils relaient les connexions chiffrées. Enfin, les « exit relays » sont ,comme leur nom l’indique les nœuds de sortie qui va être visible par le serveur, et qui va définir l’emplacement géographique de la connexion. La connexion n’est pas chiffrée par Tor entre ce nœud et le serveur web de destination.

Un nœud est donc un routeur faisant partie du réseau Tor. Il s’agit d’une machine gérée par un particulier ou une association. Lors d’une connexion avec Tor, ce dernier va charger une liste de nœuds et les utiliser aléatoirement pour faire transiter les paquets d’informations.

Votre propre relais Tor ! 

Installation : 
(désolé, bien que croyez moi que ça m’embête vraiment, je vais devoir réaliser cet article et certainement d’autres sans captures d’écran personnel.)

Sur votre distribution Linux favorite, de préférence basée sur Debian, commencez par mettre à jours les dépôts et les paquets avec :

~# sudo apt-get update ~# sudo apt-get upgrade

Tapez « O » pour « oui », si on vous demande une confirmation et installez ensuite le paquet Tor avec :

~# sudo apt-get install tor (Confirmez de nouveau avec « O ».)

Configuration du noeud.

Le fichier de configuration de Tor est à l’emplacement /etc/tor/torcc. Éditez-le avec la commande :

~# sudo nano /etc/tor/torcc

Le fichier comporte plein d’options, mais il est organisé et bien documenté (en anglais). Il se compose de trois parties. La première partie concerne le client Tor, si vous voulez par exemple créer un proxy Tor. La seconde partie concerne les fameux « hidden services« , ce sont les des sites web spécifique à Tor avec une extension en .onion. La dernière partie, celle qui nous intéresse, concerne les relais Tor, elle commence après le message :
« This section is just for the relays.« 

Les Différentes options.

La plupart des options sont déjà bien configuré par défaut, nous allons juste activer le relais et personnaliser quelques paramètres. Les lignes qui commencent par ## sont des commentaires qui expliquent la configuration, et les lignes qui commencent par # sont des options désactivées, vous devez en activer certaines, pour cela, il suffit de les dé-commenter simplement en ôtant # qui se trouve devant la ligne en question.
Voici les lignes à modifier :
(vous pouvez utiliser Crtl + W pour chercher la ligne)

ORPort 9001 : enlevez le # et laissez la valeur à 9001, c’est le port par défaut (pensez à l’ouvrir sur votre boxe internet) Nickname ididnteditheconfig : enlevez le # et remplacez le ididnteditheconfig par un nom qui servira à identifier votre relais, c’est un nom qui sera visible de tous (sans espaces, tirets, underscores ou caractères spéciaux).

Cette configuration de base suffit pour un relais Tor, mais certaines autres options peuvent être intéressantes :

RelayBandwidthRate 100 KB : En enlevant le #, vous limitez la bande passante maximale à la valeur qui suit (100 Ko par défaut). Cela vous permet de fixer une limite et de garder le reste pour vous et les autres connexions de votre machine. Vous pouvez changer la valeur comme bon vous semble. RelayBandwidtthBurst 200 KB : Cette ligne, associé à la précédente, permet d’accepter des pics de trafic au delà du RelayBandwidthRate jusqu’à cette limite. ContactInfo : Cette ligne vous permet d’afficher une adresse mail pour vous contacter (en cas de problème technique, mauvaise configuration, ect.) Attention, votre adresse sera affichée publiquement sur le Web, à la merci des robots, spammeurs, ect. BridgeRelay 1 : En enlevant le # , vous serez un « bridge » cela permet aux utilisateurs qui ne peuvent pas se connecter directement au réseau Tor (censure, proxy d’entreprise,ect) de passer par des relais comme le vôtre pour entrer dans le réseau.

Être ou ne pas être un nœud de sortie ?

Vous avez la possibilité de choisir si vous acceptez d’être le dernier nœud de connexion, ce qui signifie que c’est votre adresse IP qui sera visible par les sites web et autres services. C’est risqué, en cas d’utilisation malveillante de votre connexion (spam, téléchargement illégal, partage de contenus pornographiques, ect.) C’est vous qui serez responsable. Vous devrez prouver que vous n’êtes pas à l’origine de ses actes.
Certains ont eu de gros problèmes, comme Dmitry Bogatov, un contributeur Debian russe, responsable d’un nœud de sortie, emprisonné depuis le 10 avril (officiellement pour « appel au terrorisme« ).

Pour être certain de ne pas être un nœud de sortie, enlevez le # de la ligne :

ExitPolicy reject *:*

Si toutefois, vous savez ce que vous faites, changez la ligne en :

ExitPolicy accept *:*

Vous serez alors un nœud de sortie pour toutes les connexions.

Démarrer le relais.

Il existe d’autres options, vous pouvez vous renseigner directement avec les commentaires en anglais dans le fichier de configuration, ou sur la page officielle du projet Tor.
Pour quitter le fichier de configuration et enregistrer, faites Crtl + X, tapez « o » pour valider et faites entrer sans changer le nom du fichier. Pour démarrer votre relais TOR, exécutez la commande suivante :

~# sudo service tor restart

Rien ne s’affiche, c’est normal. Par contre, si vous avez un message du type : Job for tor.service failed
Tapez cette commande pour savoir d’où vient le problème :

~# sudo journalctl –xn

Modifiez la configuration selon l’erreur et redémarrez le relais.

Arrêter le relais et vérification.

Pour arrêter le relais, faites :

~# sudo service tor stop

Vous pouvez voir l’état actuel avec :

~# sudo service tor status

Ici, le relais est actif. Pour vérifier qu’il fonctionne et visualiser les statistiques, vous pouvez vous rendre sur le site officiel qui répertoire les relais Tor.
Entrez le nom de votre relais dans la barre de recherche. Attention, le site peut mettre plusieurs heures à répertorier votre relais. Vous pouvez maintenant voir tous les détails de votre relais : sa signature, son IP, sa bande passante, depuis combien de temps il existe, ses graphiques d’utilisation,ect. Votre relais fonctionne maintenant parfaitement. Il est prêt à faire transiter les données des utilisateurs.

(si les choses se déroulent normalement, je devrai rapidement revenir sur une deuxième partie qui consistera à créer votre propre « hidden service » ainsi que votre adresse .onion personnalisée. À très vite et merci….☼)

 

 

Si vous souhaitez avoir un avant-goût du smartphone Ubuntu, vous pouvez utiliser l’émulateur conçu pour les développeurs afin qu’ils puissent s’amuser avec l’appareil. L’émulateur Ubuntu Touch est un petit logiciel aux prétentions modestes. Veillez à l’activer avec une version d’Ubuntu qui ne soit pas antérieure à la 14.04. Il vous faudra au minimum 512mo de RAM (par défaut) mais vous pouvez en ajouter plus afin de bien profiter de ses fonctionnalités.

L’installation est simple et ce fait comme ceci :

~$ sudo apt-get install ubuntu-emulator

Lorsque vous aurez récupéré et installé les composants de base, tapez :

~$ sudo ubuntu-emulator create myubuntuphone —ARCH=i386

La commande prendra un certains temps. Si vous le souhaitez, vous pouvez remplacer le nom « myubuntuphone » par un autre selon votre convenance. Il s’agit du nom de l’instance. L’émulateur permet en effet aux développeurs de créer plusieurs instances à différentes fin. Afin d’obtenir une performance optimale, vous pouvez demander à l’émulateur d’utiliser l’architecture i386 à la place de l’architecture armhf par défaut en activant la commande ARCH=i386.

Une fois que l’émulateur aura crée l’instance, vous pourrez l’exécuter avec la commande:

~$ ubuntu-emulator run myubuntuphone —scale=0.7 —memory=1024

Le « —scale=0.7 » réduit l’UI du téléphone virtuel de 70% par rapport à la taille de l’original. Vous pouvez remplacer cette option sur l’écran avec des résolutions Full HD. Quant à l’option « —memory=1024 » permet de changer la valeur de la RAM qui est de 512mo par défaut à 1gb.

Vous pouvez également installer Ubuntu Touch sur n’importe quel appareil périphérique en suivant l’un des nombreux tutoriels en ligne, ici et là.

 

                                              [GNU/LINUX Magasine et auteur de cet article, en le remerciant, Tristan Colombo / Sans oublier la source du projet.]

Cet article présente ATOP, un outil en ligne de commandes interactif pour la supervision de performance sur des systèmes basés sur Linux. Nous explorerons ses fonctionnalités en montrant comment il permet d’extraire divers compteurs de performance avec un niveau de détail très fin. Son interface interactive en ligne de commandes étant inadaptée pour être utilisée efficacement dans un contexte de supervision opérationnelle, nous montrerons aussi comment, avec quelques astuces et des scripts spécifiques, les compteurs d’ATOP peuvent être extraits, agrégés et injectés dans Graphite (installation), afin d’être visualisés avec Grafana (installation) dans un environnement opérationnel.

 

ATOP est un outil de supervision de performance basé sur Linux. Fonctionnant en ligne de commandes à l’instar d’outils comme TOP ou HTOP, plus connu, ATOP fournit divers compteurs et un niveau de détail très fin concernant toutes les ressources critiques d’un système (CPU, mémoire, couches réseaux, disques et processus). Nous aborderons quelques-unes de ses fonctionnalités clés dans cet article. Souffrant malgré tout d’une interface de visualisation de type ncurses, c’est_à_dire en mode texte depuis un terminal, cette interface est très peu adaptée pour une supervision opérationnelle. C’est pour cela que nous nous intéressons aussi dans cet article, à montrer comment les compteurs fournis par ATOP peuvent être extraits, agrégés et visualisés à partir d’outils évolués comme Grafana. En effet, après avoir présenté les fonctionnalités d’ATOP, nous montrerons des astuces et des scripts développés par l’équipe GNU/LINUX Magasine, qui tirent parti des options offertes par ATOP pour permettre d’extraire des compteurs, de les agréger et de les injecter dans une base de données Graphite pour ensuite les visualiser avec Grafana. Ce dernier permettant de créer des tableaux de bord évolués, qui simplifient grandement l’exploration, l’analyse et le partage en temps réel des indicateurs de performances dans un contexte de supervision opérationnelle.

Cet article étant centré sur ATOP, il n’abordera que sommairement Graphite et Grafana en montrant surtout comment ces derniers peuvent être utilisés comme outils de visualisation complémentaires pour ATOP. En particulier, nous ne traiterons pas de l’installation et de la configuration de Graphite et Grafana. Du coup, il est fort possible que je sorte un peu de cet article pour y ajouter ses configurations de ces applications utile à ATOP. On verra car malgré tout, cet article met la lumière sur une fonctionnalité phare de la version 3.1 de Grafana, la dernière à être publiée lorsque cet article  été écrit. Cette fonctionnalité permet de partager des modèles de tableaux de bord via un site internet dédié.

ATOP offre diverses caractéristiques fondamentales à plusieurs égards supérieurs à celles offertes par d’autres outils de supervision de performance Linux :

► supervision de l’utilisation de toutes les ressources critiques d’un système (CPU, mémoire/swap, disque, réseau, processus). ► historisation permanente de l’utilisation des ressources pour permettre une analyse post-mortem. ► visualisation de la consommation des ressources par tous les processus. ► consommation de ressources par processus (lourd ou léger), pris individuellement. ►collecte pour chaque processus, lourd ou léger, des compteurs concernant : le CPU, la mémoire, la swap, les disques (volumes LVM inclus), la priorité, l’utilisateur, l’état, et le code de sortie. ► filtre selon l’état des processus (actifs et inactifs). ► mise en évidence des écarts de consommation dans le temps. ► cumul du temps d’activité des processus en fonction de l’utilisateur. ► cumul du temps d’activité des processus en fonction du programme exécuté. ► activité réseau en fonction des processus. ► fonctionnement en mode interactif et en mode non-interactif avec l’option d’extraction de données.

01 ) PREMIER PAS AVEC ATOP .

01.1 – Installation :

L’installation d’ATOP est simple, à partir des sources ou à partir des paquets RPM disponible en téléchargement sur le site du logiciel. Depuis la version 2.2, vous pouvez avoir des paquets spécifiques pour des systèmes basés sur systemd, en plus des paquets System V historiquement fournis.

Voici la commande pour l’installer depuis un paquet RPM depuis le site :

~$ rpm –ivh http://www.atoptool.nl/download/atop-2.2-3.sysv.x86_64.rpm

(comme vous pouvez le remarquer, après le lancement de la commande « rpm« , celui nous conseil (et j’en fait autant), d’installer l’utilitaire « alien » qui permet d’installer n’importe quel paquet « .rpm » ou « .deb » tout en le configurant par la même occasion. Ensuite, on peut remarquer que la sortie de la commande me retourne des erreurs dût à des dépendances manquantes. De ce fait, par facilité, je vais pas aller chercher toutes ses ses dépendances manquantes mais je vais utiliser l’outil « aptitude » pour voir si le paquet est disponible et si c’est le cas, l’installer par se biais.)

Voyons ça :

~# aptitude search atop

(super ! le paquet est présent.)

~# aptitude install atop

01.2 – Démarrer ATOP :

Une fois installé, le programme se lance avec la commande suivante :

~$ atop

Ceci démarra l’interface interactive basée sur ncurses que nous décrirons après.

01.3 – Comprendre les compteurs de performance d’ATOP :

L’interface d’ATOP se compose de deux parties :

► Les statistiques système, dans la partie supérieure délimitée par la bande blanche (voir capture d’écran ci-dessous), présentant des compteurs globaux d’utilisation des ressources. Par défaut ces compteurs concernent les ressources suivantes : CPU, mémoire, swap et disques. Selon des options de ligne de commandes ou des requêtes soumises depuis l’interface interactive, les compteurs liés aux ressources peuvent être affichés (swap, ordonnanceur, et bien d’autres encore). Nous y reviendrons dans la suite de cet article. Selon le niveau d’utilisation d’une ressource donnée, les compteurs associés peuvent être affichés avec une couleur spécifique afin de mettre en évidence son niveau de saturation. Sur l’image ci-dessous, on peut par exemple observer que les compteurs liés au premier CPU, chargé à 76%, sont en rouge.

La consommation de ressources par les différents processus dans la partie inférieure de l’interface : ici également l’utilisateur peut choisir quelle catégorie de ressource sera affichée (réseau, utilisateur, mémoire, ou autre). Comme pour les compteurs globaux ce choix peut se faire via des options en ligne de commandes où à partir des requêtes soumises depuis l’interface interactive. Nous y reviendrons.

02 ) QUELQUES OPTIONS UTILES.

Dans cette section, nous présenterons quelques options utiles pour un usage classique d’ATOP. Ne pouvant énumérer toutes les options, vous pouvez consulter la documentation d’ATOP pour aller plus loin.

02.1 – Sélectionner la catégorie des compteurs à afficher :

ATOP accepte différentes options de ligne de commandes avec, pour chacune, une commande équivalente que l’on peut soumettre depuis l’interface interactive ncurses.
Ces options permettent de sélectionner la catégorie des ressources que l’on souhaite superviser. Par défaut, les compteurs fournissent des informations générales sur l’utilisation du CPU par les processus. Nous listons ci-après quelques autres options d’affichage.

1 ► Mémoire : pour activer l’affichage des compteurs suivant la consommation mémoire, il suffit de lancer la commande atop avec l’option -m, ou alors, après le lancement de l’interface graphique, appuyer sur la touche . ~# atop –m 2 ► Disque : l’affichage des compteurs suivant l’utilisation disque se fait avec l’option -d, ou alors depuis l’interface graphique. 3 ► Réseau : l’activation de l’affichage des compteurs réseau se fait en lançant la commande atop avec l’options -n ou depuis l’interface graphique. Sachant que Linux ne fournit pas nativement de compteurs réseau par processus, atop fournit pour cela un module noyau spécial appelé « netatop« , qui s’appuie sur « nefilter » pour collecter ses compteurs.

~# atop –n

02.2 – Définir l’intervalle de rafraîchissement :

Au premier affichage, c’est-à-dire après le lancement du programme atop, les compteurs de performances affichés sont ceux calculés depuis le démarrage de la machine. Ensuite les compteurs sont rafraîchis pour ne prendre en compte que les changements ayant eu lieu depuis le dernier rafraîchissement.

La durée de rafraîchissement par défaut est de 10 secondes, mais peut être changée de deux manières :

► Au lancement d’atop, en spécifiant la durée de l’intervalle en secondes. Par exemple, la commande suivante lancera le programme avec la durée de rafraîchissement de 5 secondes : ~$ atop 5 ► Via l’interface ncurses comme suit : appuyer sur la touche , saisissez la valeur souhaitée en secondes, et appuyer sur la touche <Entrée> pour valider et prendre en compte le changement immédiatement.

02.3 – Enregistrer les compteurs d’atop pour une analyse ultérieure :

Comme alternative à l’interface interactive qui nécessite que l’utilisateur soit présent devant sa console pour détecter d’éventuelles anomalies, atop permet un mode de fonctionnement où les données collectées sont automatiquement stockées dans un fichier sur le disque pour une analyse ultérieure.

02.3.1 – Collecter et stocker les données dans un fichier :

Il faut pour cela utiliser l’option -w, suivie d’un chemin de fichier. Par exemple, la commande suivante collectera et stockera les données dans un fichier nommé output.atop. Cette option peut être complété avec les autres options d’atop, conformément à la documentation.

~$ atop –w output.atop

Les données sont stockées sur une forme compressée afin de réduire l’empreinte disque.

Atop fournit par défaut un service démon, atopd, qui se base sur cette fonctionnalité pour collecter des données en arrière-plan. Ce démon permet de plus de gérer la rotation automatique des fichiers générés. Cette rotation vise à éviter d’avoir des échantillons très volumineux et donc l’analyse prendrait beaucoup de temps à cause de la décompression et du chargement en mémoire.

Grâce aux données stockées sur disque, l’administrateur système peut, en cas d’anomalie constatée sur un système, faire une analyse a posteriori pour étudier la cause de l’anomalie. En rappelant qu’atop garde les données concernant à la fois les processus actifs, inactifs, et même morts, ceci permet de faire des analyses post-mortem. C’est-à-dire des analyses qui prennent en compte des processus ayant cessé de fonctionner. L’analyse d’une anomalie par l’administrateur système peut donc facilement prendre en compte des processus qui se sont déjà terminé, normalement ou anormalement (exemple : crash, interruption utilisateur).

~# atop –P NET,MEM,CPU,cpu 2

 

02.3.2 – Visualiser les données depuis un fichier :

Avec des données collectées dans un fichier, atop fournit l’option -r qui permet de spécifier un fichier d’entrée à partir duquel les données vont être lues. Comme illustré sur l’exemple suivant, cette option attend en argument le chemin vers un fichier généré par atop. Si le fichier n’est pas reconnu comme un fichier atop, la commande échouera.

~$ atop –r output.atop

Pour permettre une analyse fine de ces données stockées, atop offre une option pour spécifier l’intervalle de temps concerné par l’analyse. Il faut pour cela utiliser l’option -b (date de début) et, facultativement, l’option -e (heure de fin), suivies respectivement d’une heure suivant le format hh:mm. L’exemple suivant indique que les données à analyser doivent être comprises entre 04:00 et 04:30 inclus.

~$ atop –r output.atop –b 04:00 –e 04:30

02.4 – Extraire les compteurs d’atop sous forme formatée :

L’option -p de la commande atop permet d’afficher le sortie sous forme tabulaire. Les compteurs sont alors affichés ligne par ligne avec les champs séparés par des espaces. L’objectif est de faciliter le traitement des compteurs via des outils tiers de post-traitement.

Cette option doit être accompagnée d’un ou plusieurs filtres permettant de spécifier la ou les catégories de ressources à considérer (CPU, mémoire, disque, réseau, ect.). Nous verrons un exemple d’utilisations ci-dessous. Notons en particulier que le filtre ALL (ex : atop –P ALL) permet de sélectionner l’ensemble des ressources. La liste complète des filtres peut être consultée via la page de manuel d’atop.

02.4.1 – Cas d’utilisation :

La commande suivante permet d’extraire toutes les cinq secondes les compteurs liés à tous les CPU, à la mémoire, au réseau et produit une sortie formatée comme sur l’image ci-dessous. Remarquons la différence entre CPU et cpu, en majuscule et en minuscule. Avec cpu en minuscule, il s’agit de récupérer les compteurs pour chaque cœur CPU disponible sur le système, tandis que dans le second cas où CPU est en majuscule, il s’agit des compteurs globaux issus de l’agrégation des compteurs des différents cœurs disponibles.

~# atop –P NET,MEM,CPU,cpu 2

02.4.2 – Interprétation des entrées :

Les entrées générées par l’option –P s’interprètent comme suit :

► Le marqueur RESET, qui apparaît une seule fois à la première ligne sur la ligne entière, indique que les compteurs qui vont suivre ont été collectés depuis le dernier démarrage du système. ► Les marqueurs SET, apparaissant également sur une ligne entière, délimitent les données collectées durant chaque intervalle de mise à jour. ► Les compteurs collectés pendant chaque intervalle de temps apparaissent entre deux marqueurs SET, ou entre le marqueur RESET et le premier marquer SET. ► Chaque ligne, hormis les lignes avec un marqueur RESET ou SET, contient différents compteurs pour une catégorie de ressource donnée. Chaque ligne commence invariablement par les six champs suivants : une étiquette indiquant la catégorie de ressource concernée (CPU, MEM, NET …), le nom d’hôte de la machine (ex : localhost), la date et l’instant d’échantillonnage en seconde depuis l’epoch (01/01/1970), la date d’échantillonnage sous le format YYY/MM/DD, l’heure d’échantillonnage sous la forme HH:MM:SS, et enfin la durée de l’intervalle d’échantillonnage (2 secondes dans l’exemple précédent). Les champs suivants varient selon la catégorie de la ressource concernée.

Pour une interface réseau par exemple, les champs suivants seront : le nom de l’interface, le nombre de paquets reçus, le nombre d’octets reçus, le nombre de paquets transmis, le nombre d’octets transmis, le débit, et le mode de transmission (0=half-duplex, 1=full-duplex). À préciser qu’une ligne réseau avec la valeur upper au niveau du nom ne correspond pas à une interface réseau, mais aux données enregistrées au niveau des couches supérieurs de la pile TCP/IP. Les champs indiquent respectivement le nombre de paquets transmis en UDP, le nombre de paquets reçus par IP, le nombre de paquets reçus en UDP, le nombre de paquets transmis en UDP, le nombre de paquets reçus par IP, et le nombre de paquets retransmis par IP. Bien vouloir se référer au manuel d’atop pour une description exhaustive des différentes entrées selon la catégorie de ressource.

On peut constater à partir de ce cas d’utilisation que les compteurs et le niveau de détails fournis par atop sont assez fins. En revanche, les compteurs bruts ainsi produits ne sonbt pas toujours facilement interprétables pour tirer des conclusions. Pour le cas du réseau, nous aurions, par exemple, espéré avoir des débits en bits par seconde, au lieu des quantités d’octets échangés durant un intervalle de temps donné. Mais, rassurons-nous, ces informations de haut niveau que nous manipulons au quotidien peuvent être déduites par agrégation des compteurs bruts. C’est ce que nous allons voir sur le plan théorique.

03 ) VISUALISER LES DONNÉES D’ATOP AVEC GRAFANA.

Nous allons voir comment les compteurs retournés par atop peuvent être agrégés pour avoir des indicateurs de performance de haut-niveau  qui seront injectés dans le moteur de visualisation de Grafana afin de simplifier leur exploitation. Nous supposons que le lecteur est familier et dispose déjà d’une installation fonctionnelle de Grafana avec Graphite (ce qui n’est pas mon cas. Désolé) comme source de données. Si ce n’est pas le cas (comme moi), vous pouvez vous inspirer de la documentation disponible ici et là.

                                                  (ça donne envie, n’est-ce pas ?)

03.1 – Agréger les compteurs sous forme de métriques Graphite :

La démarche repose sur deux scripts écris par l’équipe GNU/Linux Magasine (que je remercie au passage encore une fois) et téléchargeables sur Github : collect_atop_counters.sh et push_graphite_formatted_data_live.py. En s’appuyant sur ces scripts, la suite de commandes suivante permet d’extraire d’atop des compteurs, concernant le réseau, la mémoire et les CPU (atop –P NET,MEM,CPU,cpu), de les agréger sous forme d’indicateurs de performance de haut niveau, puis de les injecter sous forme de métriques dans une base de données Graphite. Ces indicateurs de performances peuvent ainsi être visualisés grâce à Grafana avec la commande suivante :

~$ atop –P NET,MEM,CPU,cpu | \
collect_atop_counters.sh | \
push_graphite_formatted_data_live.py

Dans un premier temps, les compteurs d’atop sont extraits via la commande atop –P NET,MEM,CPU,cpu. Ce qui produit en sortie des entrées similaires à celles présentées plus haut.

Le résultat est redirigé, via un mécanisme de pipe, au script collect_atop_counters.sh qui fonctionne comme suit : les différents compteurs issu d’atop sont agrégés pour produire des indicateurs de haut niveau, incluant entres autres, le débit réseau en bit par seconde, le nombre de paquets émis et reçus chaque seconde, le pourcentage d’utilisation de la mémoire, le niveau de charge global et individuel des CPU, ect. Cela génère en sortie les métriques. Graphite associés aux indicateurs calculés.

Chaque ligne correspond à une métrique sous la forme « clé valeur timestamp« . Les clés exploitent la capacité de gestion de structure arborescence par Graphite. Chacune suit sur la nomenclature : userPrefix.timeseries.hostname.resourceType.resourceId.metricKey, où : userPrefix est un préfixe défini librement par l’utilisateur (graphite dans l’exemple) ; timeseries est une valeur constante ; hostname est le nom d’hôte de la machine tel que retourné par atop ; resourceType est une variable déterminée dynamiquement en fonction du type de ressource (CPU, MEM,NET), resourceId correspond à l’identifiant de la ressource tel que que retourné par atop (ex : eth0 pour une interface réseau) ; metricKey correspondau nom associé à l’indicateur de performance généré (ex : recvthroughput, pour le débit de réception réseau).

Ces métriques sont ensuite reprises par un second script, push_graphite_formatted_data_live.py, grâce au mécanisme de pipe également, qui se charge de les injecter dans une base de données Graphite à travers le démon carbon cache. Les métriques sont injectées par lot en utilisant le protocole pickle. Ce qui vise à limiter les risques de saturation du démon et du réseau avec des petites requêtes. Le script nécessite deux variables d’environnement (CARBON_CACHE_SERVER et CARBON_CACHE_PICKLE_PORT), indiquant respectivement l’adresse réseau et le port d’écoute du démon carbon. Par défaut, ces variables sont définies pour se connecter sur la machine locale et le port 2004 (port par défaut du protocole pickle).

03.2 – Construire, explorer et partager des tableaux de bord Grafana :

Les tableaux de bord générés à l’aide des scripts comprend quatre panneaux montrant des graphes liés : au pourcentage d’utilisation globale et par cœur des CPU, niveau d’utilisation de la mémoire, débit d’envoi et de réception pour chaque interface réseau, nombre de paquets émis et reçus via chaque interface réseau.

Grâce à ce type de tableau de bord, nous voyons comment nous pouvons superviser en temps réel, depuis des écrans dans une salle de supervision par exemple, les performances de nos serveurs. Depuis la version 3.1.0, il est possible de partager des tableaux de bord sur le site de Grafana.net. En exploitant cette fonctionnalité, vous pourrez partager des tableaux de bord que vous pourrez ensuite télécharger (modèles) pour les utiliser conjointement avec les scripts fournis précédemment.

CONCLUSION :

Nous avons vu dans cet article l’outil atop, qui est un outil en ligne de commandes interactif pour la supervision de performance sur des systèmes basés sur Linux. Puissant et pointu au niveau détail, il souffre cependant d’une interface impraticable dans un contexte opérationnel où une visualisation rapide est capitale. C’est pour cela que nous avons montré comment grâce à quelques astuces et scripts, les compteurs d’atop pouvaient être  aisément extraits, agrégés, et injectés dans un moteur de visualisation basé sur Graphite et Grafana afin de créer des tableaux de bord flexibles pour une supervision opérationnelle. Atop est un outil riche, et nous ne pouvions aborder toutes ses fonctionnalités dans un seul article. Nous invitons donc les lecteurs à consulter la page de manuel pour en apprendre d’avantage. Le dépôt Github des scripts d’exemple fournis reste ouvert aux contributions.

                                          (Merci beaucoup à l’auteur de cet article , Tristan Colombo , son projet, et à l’équipe GNU/Linux Magasine]

Bonjour et bienvenus dans la quatrième parties consacré à la ligne de commandes Linux. Dans celle-ci, nous allons aborder ensemble le sujet du « scripts shell ».

Au programme :

► Enchaîner plusieurs commandes en écrivant un script :
l’étape suivante consiste à savoir écrire un script, en commençant par choisir les outils appropriés.

► Écrire un premier script shell :
nous allons créer ici notre tout premier script, qui consiste à afficher un simple texte à l’écran. Reste à savoir comme rendre le script exécutable et comment l’exécuter ?

► Rendre un script paramétrable en utilisant des variables :
le comportement d’un script peut être modifié à loisir dès lors que l’on y intègre des valeurs qui peuvent être changées comme bon vous semble.

► Exécuter des commandes suivant des conditions précises :
ici encore, nous allons voir comment le comportement d’un script peut différer selon certains paramètres.

► Exécuter plusieurs fois une commande sans avoir à la ré-écrire :
les premiers scripts que l’on cherche à écrire concernent souvent le traitement par lots de fichiers.

01 ► ENCHAÎNER PLUSIEURS COMMANDES EN ÉCRIVANT UN SCRIPT .

Vous savez utiliser le shell depuis une console, exécuter des commandes simples ou même plus complexes à l’aide de redirections et de pipes ( | ), mais maintenant vous voulez enchaîner les commandes. Comment faire ? Écrire un script !

1 ) Mais, c’est quoi un script ?

Comme vous avez pu le lire dans les précédents articles, lorsque vous ouvrez une console ou lorsque vous ne vous connectez pas à Linux en mode graphique, vous aboutissez sur le shell de votre système et c’est là que vous pouvez taper et exécuter vos diverses commandes.

Ces commandes admettent généralement la même structure  : le nom de la commande suivi parfois d’options (précédées du caractère – ou de —) et éventuellement d’arguments.
Par exemple, dans la commande ls –aild /home, ls est la commande, –aild représentent les options (–aild est un raccourci pour –a –i –l –d ) et /home est l’argument.

Nous souhaitons maintenant exécuter un ensemble de commandes contenues dans un fichier. Il faudrait en plus rendre paramétrable l’exécution de code à l’aide, comme nous l’avons vu précédemment, d’options et de paramètres.

Par exemple, nous pourrions avoir une commande prepare_une_boisson permettant de préparer du café, du thé,ect. Le comportement général serait le même, à quelques différences près que nous pourrions régler en fournissant un paramètre à la commande : prepare_une_boisson cafe ou prepare_une_boisson the . Et pour préciser encore plus notre attente, nous pourrions ajouter des options : prepare_une_boisson cafe –type=fort ou prepare_une_boisson the –type=earl-grey.

En plus des commandes, le shell offre la possibilité d’utiliser des structures de contrôle qui permettront de gérer de manière précise l’exécution des commandes : nous pourrons ainsi exécuter de manière répétitive un certain nombre d’entre elles et éventuellement conditionner leur exécution.

La mise en œuvre de l’ensemble des mécanismes précédemment décrits permet de créer ce qu’on appel un script shell .

2 ) Quels outils utiliser pour écrire mes scripts ?

Les scripts shell sont des fichiers textes tout ce qu’il y a de plus classique. Pour créer un fichier et y insérer du texte, on a deux possibilités :

1 : La méthode « geek », tout en ligne de commandes :

~$ echo « Contenu de mon fichier texte » > fichier.txt

Ici, vous créerez un fichier nommé fichier.txt et contenant la phrase « Contenu de mon fichier texte » .Si vous souhaitez ajouter du texte, il faudra le concaténer au contenu précédent :

~$ echo « Suite de mon fichier » >> fichier.txt

Pour lire le contenu complet de votre fichier, vous aurez le choix entre la commande more ou la commande cat :

~$ more fichier.txt
Contenu de mon fichier texte
Suite de mon fichier

~$ cat fichier.txt
Contenu de mon fichier texte
Suite de mon fichier

Là où ça se corse, c’est pour modifier le contenu du fichier !
Sans utiliser des outils aussi sophistiqués que sed ou awk, vous devrez employer la commande tr permettant de rechercher dans une chaîne les occurrences d’une chaîne et de les remplacer par une autre chaîne :

~$ cat fichier.txt | tr « fichier » « petit fichier » > fichier.txt

Comme vous le voyez, cette ligne fait intervenir deux commandes (cat et tr), un pipe et une redirection… Pour frimer devant les filles quand on est au collège, ou pour faire « pro » dans les films grand public (voir la mythique scène de Jurassic Park : « It’s a Unix system…I know this »), c’est ce qu’il faut. Sinon, il faut reconnaître que c’est quand même un peu complexe pour pas grand chose ! De plus, le risque d’erreur est très élevé. On utilisera donc préférentiellement la méthode suivante.

2 : méthode dite « classique », l’utilisation d’un éditeur de texte :

Attention, si l’on parle ici d’éditeur de texte, il existe une différence avec les logiciels de traitement de texte. Un éditeur de texte est capable de lire et d’écrire du texte : chaque caractère visible (en dehors des espaces, tabulations et autres sauts à la ligne) sera visible dans le fichier. Dans un traitement de texte, des informations supplémentaires sont sauvegardées sous divers formats : police sélectionnée, taille de la police, style, ect.

Les éditeurs de texte sont conçus pour améliorer la rapidité d’écriture de lignes de codes. Pour cela, ils disposent d’une fonctionnalité de coloration syntaxique permettant d’afficher les « mots » de votre programme de différentes couleurs en fonction de leur catégorie (mot-clé, valeur numérique, opérateur arithmétique, ect) .

Il existe de très nombreux éditeurs de texte, plus ou moins évolués, disposant de plus ou moins de fonctionnalités. On distinguera deux catégories d’éditeurs :
► les éditeurs en mode console.
► les éditeurs en mode graphique.

Voici une liste non exhaustive de ces différents éditeurs, accompagnés de leur catégorie et d’une brève description :

► Éditeurs graphiques :

gedit, kedit, nedit => Famille d’éditeurs graphiques très simples fournissant la coloration syntaxique, l’ouverture et l’enregistrement de fichiers et les copier-coller (le minimum nécessaire). gvim => Version graphique de vim, avec l’ajout d’une barre d’outils, ect. xmacs => Version graphique de emacs. eclipse => Éditeur de texte « lourd » pouvant être amélioré par l’ajout d’extensions. Convient éventuellement au développement de code dans différents langages tels que Java ou C (et encore), mais certainement pas pour des scripts shell !

 ► Éditeurs en mode console :

nano => Éditeur simpliste mais qui fait son boulot . vim => Amélioration de l’éditeur vi. Vim signifie « Vi IMproved », soit vi amélioré. Il est installé par défaut avec toute distribution Linux : quand plus rien ne fonctionne, il reste vi! Éditeur entièrement paramétrable, améliorable par l’ajout d’extensions, contenant de nombreux raccourcis clavier permettant un développement rapide. Sa caractéristique principale est la possibilité de passer en trois modes distincts : commande (action), insertion (écriture) et visuel (sélection de code par exemple). Si je devais lui trouver un défaut, ça serait la difficulté à prendre en main lors des premiers lancement. emacs => Équivalent de vim, développé par Richard Stallman. Chez les fanatiques, emacs est les concurrent et l’opposé de vim. Les fans d’emacs vont jusqu’à dire : « VI VI VI, le nombre de la bête ! »

Les critères de choix d’un éditeur sont propres à chacun et il est très difficile de dire qu’il vaut mieux en choisir un plutôt qu’un autre (même si vous pourrez rencontrer de très nombreux informaticiens qui vous vanteront leur éditeur, bien plus puissant et ergonomique que le vôtre !)

À titre personnel, j’utilise nano même si vim reste l’un des plus efficace bien qu’il faut accepter de passer par une longue phase d’apprentissage pour l’utiliser efficacement et il est jamais conseillé à des personnes souhaitant commencer à développer ou simplement écrire quelques scripts.

Pour un usage ponctuel, gedit, l’éditeur par défaut de l’environnement graphique GNOME, est largement suffisant ! Si vous utilisez un quelconque autre éditeur de texte régulièrement, vous maîtriserez son emploi et serez donc bien plus performant avec ce dernier, même s’il n’apparaît pas forcément comme étant le plus adapté… Continuez donc à l’utiliser !

02 ► ÉCRIRE UN PREMIER SCRIPT SHELL .

Il faut un début à tout. Avant de se lancer dans l’écriture de scripts complexes, il vaut mieux être certain de savoir précisément ce que l’on fait. La tradition dans le monde de l’informatique est de créer un programme affichant un simple message « Hello World ! » (le fameux « Hello World ! » …). Nous ne dérogerons pas à la règle … mais nous l’adapterons.

1 )  Comment exécuter un fichier script ?

Pour exécuter une commande shell, il existe deux alternatives :

La première méthode est aussi la moins pratique : il faut lancer un shell en lui donnant en paramètre le nom d’un fichier contenant des commandes à exécuter.
Une fois que vous aurez crée et enregistré votre script avec l’extension .sh, vous devez appeler la commande correspondant à votre shell, suivie du nom de votre script.

Supposons que nous utilisons le shell Bash et que notre script se nomme monScript.sh. La commande à exécuter sera alors :

~# bash monScript.sh

La seconde méthode consiste à indiquer directement dans le fichier quelle est la commande (le shell) qui permettra de l’interpréter. Cette solution est un tout petit peu plus longue à mettre en place (une ligne de plus à écrire), mais elle est bien plus pratique pour l’utilisateur. En effet, ce dernier n’aura qu’à écrire le nom de la commande pour l’exécuter.

Pour mettre en place cette solution, il faut indiquer sur la première ligne du fichier de script quel est l’interpréteur qui permettra d’exécuter les commandes des lignes suivantes. Cette ligne possède une syntaxe particulière : les caractères #! suivis du chemin absolu (depuis la racine) vers l’interpréteur.

Dans le cas du Bash, nous aurons comme première ligne du fichier monScript.sh :

#!/bin/bash

Toutefois, pour que le mécanisme fonctionne, vous devrez rendre ce script exécutable (attention à la gestion des droits utilisateurs (u), groupe (g) et autres (o)). Il faut utiliser la commande chmod pour modifier les droits d’un fichier en lecture (r), écriture (w) et exécution (x). Cette commande, que vous pourrez voir plus en détail dans un article suivant, peut être utilisée de deux manières que nous allons tester sur le script monScript.sh .

La première méthode consiste à garder les droits actuels du fichier et à ajouter ou à retirer des droits en fonction des utilisateurs :

~# chmod u+x monScript.sh; chmod o-rw monScript.sh; ls -al monScript.sh

Dans cet exemple, nous avons pris le fichier monScript.sh avec les droits qui lui avaient été affectés par défaut (si vous n’avez pas modifié le masque, ces droits sont lecture et écriture pour l’utilisateur et le groupe et seulement lecture pour les autres), puis nous avons ajouté le droit d’exécution pour l’utilisateur et retiré les droits de lecture et d’écriture pour les autres. Au final, les droits du fichier sont donc lecture, écriture et exécution pour l’utilisateur, lecture et écriture pour le groupe  et aucun droit pour les autres.

La seconde méthode consiste à indiquer sous forme de codage octal les droits de chaque groupe dans l’ordre utilisateur, groupe, puis autres. Un code octal commence par le chiffre 0, puis un chiffre en base 8 pour les droits de chaque groupe : 0 pour aucun droit, 1 droit d’exécution, 2 droit d’écriture, 4 droit de lecture, ou une combinaison de ces droits.

Une fois que vous aurez ajouté la ligne indiquant le programme capable d’interpréter votre script et que vous aurez donné les droits en exécution à votre fichier, il ne vous reste plus qu’à taper le nom de votre fichier dans un terminal pour celui-ci soit exécuté …

2 ) Premier script : « Hello GNU/LINUXIENS !« 

Nous allons maintenant pouvoir réaliser notre premier script shell.

Pour que l’exemple reste le plus simple possible, nous allons seulement utiliser la commande d’affichage echo. Cette commande admet pour paramètre une chaîne de caractères qu’elle imprimera sur le périphérique de sortie standard (par défaut, il s’agit de l’écran). Nous pouvons utiliser cette commande en shell interactif en tapant directement après le prompt :

~$ echo « Hello GNU/LINUXIENS ! »

Pour créer un script qui exécutera cette même commande, il faut ouvrir un fichier texte (que nous appellerons ici hello.sh) :

~# nano hello.sh

et y ajoutez-y ceci à l’intérieur :

#!/usr/bin/bash # Nous allons afficher un message ! echo « Hello GNU/Linuxiens ! »

Les caractères  de la ligne 3 qui suivent le caractère # ne sont pas interprétés (sauf cas spécial du shebang de la première ligne). Ainsi la phrase de la troisième ligne constitue un commentaire permettant d’indiquer à un lecteur, éditeur (nous sommes dans l’open-source ! Ne l’oublions pas.) du fichier ce qu’on a souhaité réaliser.

On ne soulignera jamais assez l’importance des commentaires dans un code : le message permettra peut être d’aider un développeur qui veut améliorer votre script, ou plus simplement, il vous aidera vous ! En effet, si vous délaissez un script quelques temps, puis que vous y revenez pour corriger un bug ou y apporter une amélioration, vous serez heureux de retrouver ces petits messages vous indiquant ce que fait le code, pourquoi avoir choisi d’exécuter telle commande plutôt que telle autre. Et ne croyez pas qu’il faille laisser passer beaucoup de temps pour « oublier » la structure d’un code pour pouvoir le maintenir et augmenter sa durée de vie (un code in-maintenable n’évolue plus et il est voué à une mort certaine).

Notez que les commentaires ne commencent pas forcément une ligne. En ligne 4, nous aurions pu écrire :

echo « Hello GNU/Linuxiens ! » # Ceci est un commentaire

Les lignes vides ne sont pas interprétés non plus : utilisez-les pour aérer votre code et le rendre plus lisible en regroupant les lignes de même « fonction« . Comme dans un texte, vous aurez ainsi des « paragraphes » permettant de faciliter la lecture.

Pour tester le script, rendez votre fichier exécutable avec la commande chmod comme vu précédemment :

~# chmod u+x hello.sh

puis lancez votre script simplement à l’aide de la commande :

~# bash hello.sh

Bien sûr, tout ceci ne constitue que la base de l’élaboration des scripts, mais nous voyons que nous pouvons déjà enchaîner des commandes que nous tapions précédemment dans le shell : il suffit de créer un fichier et d’y écrire les commandes dans l’ordre dans lequel on souhaite qu’elles s’exécutent.

Par exemple, nous pouvons modifier notre exemple ou en créer un nouveau script que nous nommerons hello2.sh de manière à ce qu’il se déplace dans le répertoire home/votre_login/Documents et qu’il crée un fichier hello.txt contenant la phrase « Hello GNU/Linuxiens ! » :

#!/usr/bin/bash # Déplacement dans le répertoire /home/votre_login/Documents cd /home/LinuxFrench/Documents # Création du fichier echo « Hello GNU/Linuxiens ! » > hello.txt # Affichage d’un message echo « le fichier hello.txt a été crée… »

On vérifie :
(n’oubliez pas de rendre votre script exécutable!)

~# bash hello2.sh; ls /home/votre_login/Documents/hello.txt; cat /home/votre_login/Documents/hello.txt

0403 ► RENDRE UN SCRIPT PARAMÉTRABLE EN UTILISANT DES VARIABLES .

Un script permet de placer des commandes dans un fichier et de les exécuter … Mais si l’on ne peut pas faire varier légèrement son comportement en changeant des valeurs comme des chaînes de caractères ou des nombres, l’intérêt est très limité. Heureusement pour nous, il existe les variables.

01 ) Qu’est-ce qu’une variable ?

Une variable n’est jamais qu’un espace réservé en mémoire dans lequel on peut écrire des données. Pour accéder plus simplement à cet espace, on lui donne un nom (utiliser une adresse du type 0x278faa0 est nettement moins pratique !). On peut voir une variable comme une boite sur laquelle on colle une étiquette portant un nom.

Si nous plaçons dans notre boite un carré de chocolat et que nous inscrivons sur l’étiquette « miam_miam« , nous pourrons dire « Tiens, je mangerais bien un miam_miam » et cela se traduira par « Tiens, je mangerais bien un carré de chocolat« . Le fait de modifier le contenu de la boite modifiera le sens de notre phrase. Si nous plaçons maintenant dans la boite un kiwi, la traduction donnera « Tiens, je mangerais bien un kiwi« . ainsi, nous pouvons décrire une seule fois notre action et le rendre paramétrable à l’aide d’une variable qui se nomme ici miam_miam.

Pour revenir dans un cadre un peu plus formel, une variable est définie par un identifiant (son nom) et une valeur (son contenu). Lorsque l’on définit une variable, on réserve un espace mémoire (par exemple 0x278faa0) et on lui associe un nom (par exemple miam_miam), puis on y stocke une valeur (le « carré de chocolat » de l’exemple précédent). Lorsque nous utiliserons notre variable, l’interpréteur lira le nom de la variable, le traduira en adresse mémoire et ira rechercher l’information en mémoire à l’emplacement indiqué.

Passons maintenant à un aspect plus pratique et voyons la syntaxe à utiliser pour manipuler des variables.

02 ) Créer une variable .

La définition d’une variable se fait de manière très naturelle, comme en mathématique : identifiant=valeur (attention de ne surtout pas mettre d’espace entre la fin du nom de la variable et le signe égal !). La valeur pourra bien sûr être un nombre, une lecture ou chaîne de caractères (encadrée par des guillemets « … » ou des quotes « … ») ,ect.

Pour utiliser la valeur contenue dans une variable, il faudra la faire précéder du caractère $. Ainsi, si la variable a vaut 15, pour accéder à la valeur de a je devrais écrire $a.

reprenons l’exemple utilisé pour notre premier script (hello.sh), où le texte à afficher sera cette fois placé dans une variable :

#!/usr/bin/bash msg=« Hello GNU/Linuxiens ! » echo $msg

msg est la variable contenant la chaîne de caractères « Hello GNU/Linuxiens ! » et $msg représente le contenu de la zone mémoire référencée par le nom de la variable msg. Ainsi, lors de l’exécution, $msg sera remplacé par la valeur « Hello GNU/Linuxiens ! » et nous exécuterons donc echo « Hello GNU/Linuxiens ! ».

Il également possible d’exécuter des opérateurs sur les variables. Si les variables sont des entiers, on pourra utiliser les opérateurs arithmétiques classiques, plus % pour le reste de la division entière et ** pour la puissance. La syntaxe est alors un peu particulière et il y a deux manière de faire :

01 ► soit on encadre l’opération par $((…)), ce qui donne par exemple : a=$((7+8))
02 ► soit on utilise la commande let <> : let <<a=7+8>>

Dans le cas des chaînes de caractères, pour réaliser une concaténation (coller des chaînes bout à bout), il suffit de mettre les variables côte à côte. Par exemple si a=>>GNU/>> et b=>> Linuxiens>>, alors on peut écrire msg=$a$b et la variable msg contiendra la valeur « GNU/Linuxiens ».

Voici un tableau récapitulatif indiquant la valeur d’une variable après les opérations vues en exemple :

01 ) ► COMMANDE => var=7+8 ► VALEUR DE LA VARIABLE => 7+8 (résultat de : echo $var)02 ) ► COMMANDE => let <<var=7+8>> ► VALEUR DE LA VARIABLE => 1503 ) ► COMMANDE => var=$((7+8)) ► VALEUR DE LA VARIABLE => 1504 ) ► COMMANDE => a=>>Hello GNU/>>                                   var=$a>>Linuxiens>> ► VALEUR DE LA VARIABLE => GNU/Linuxiens05 ) ► COMMANDE => a=>>Hello GNU/>>                                   b=>>Linuxiens>>                                   var=$a$b ► VALEUR DE LA VARIABLE => Hello GNU/Linuxiens

03 ) Les différents types de variables.

3.1 – Les variables d’environnement :

Les variables d’environnement sont notées en majuscules. La partie 02 de la série d’articles sur la « ligne de commandes » explique déjà assez longuement à quoi servent ces variables. Sachez simplement que, d’un point de vue syntaxique, pour avoir accès à leur valeur, vous pourrez les utiliser comme des variables « normales » en préfixant leur nom par le caractère $.

3.2 – Variables spéciales :

Il existe un certain nombre de variables spéciales qui sont initialisées au lancement de chaque script. Voici un tableau les résumant :

► VARIABLE => $0 ► DESCRIPTION => le nom du script (par exemple, si le script se nomme monScript.sh et qu’il est appelé depuis son répertoire de stockage, la valeur de $0 sera ./monScript.sh)► VARIABLE => $1, $2, … ► DESCRIPTION => les arguments passés au script : $1 est le premier argument, ect.► VARIABLE => $* ► DESCRIPTION => la liste de tous les arguments passés au script, séparés par un espace.► VARIABLE => $# ► DESCRIPTION => le nombre d’arguments passés au script.► VARIABLE => $7 ► DESCRIPTION => le code de retour de la dernière commande exécutée. Toutes les commandes shell renvoient une valeur : 0 lorsque la commande s’est exécutée correctement et sinon, un code d’erreur compris entre 1 et 255. Par exemple, après un appel à ls , $? contiendra la valeur 0. Par contre, après un appel à ls /rep_inexistant , $7 contiendra la valeur 2 (on suppose que le répertoire /rep_inexistant n’existe pas, bien sûr).► VARIABLE => $! ► DESCRIPTION => le numéro de processus de la dernière commande lancée en tâche de fond.► VARIABLE => $$ ► DESCRIPTION => le numéro de processus du script lui-même.

Grâce à ces variables, l’utilisateur pourra transmettre des données au script sans pour autant avoir à modifié le script. On peut donc définir des actions génériques, que l’on modifiera lors de l’appel en indiquant un ou plusieurs arguments.

Voici un exemple très simple permettant de voir le contenu de ces variables en fonction des arguments passés lors de l’appel du script.
Nous nommerons ce script variables.sh :

#!/bin/bash echo « Le script s’appelle » $0 echo « Vous avez passé » $# « arguments. » echo « La liste de ces arguments est : » echo $* echo « Le premier argument est : » $1 echo « Le deuxième argument est : » $2

Lors de l’exécution de ce script, si vous lui passez en paramètres quelques valeurs, vous obtiendrez l’affichage suivant :

~# bash variables.sh arg1 arg2 arg3
Le script ………
……………………………
………………………………………

Si, plutôt que de transmettre les données au script sous forme d’arguments, vous préférez demander à l’utilisateur de les saisir au clavier durant l’exécution de votre code, vous pourrez le faire grâce à la commande read .Cette commande permet de lire des données au clavier et de les stocker dans une variable dont le nom est spécifié à la suite de la commande : read nomVariable. La variable contenant la saisie utilisateur sera alors utilisée comme n’importe quelle variable en la préfixant par le caractère $ pour avoir accès à sa valeur.

Voici un exemple utilisant la commande read :

#!/usr/bin/bash echo « Comment vous appelez-vous ? » read nom echo « Salut » $nom

À la lecture de la ligne 4, l’exécution du script sera suspendu jusqu’à ce que l’utilisateur ait saisi un texte et qu’il l’ait validé en appuyant sur la touche . Le texte sera alors stocké dans la variable nom et l’exécution du script reprendra en ligne 5 pour afficher le message.

Ce qui nous donne :

~# bash read.sh
Comment vous-appelez vous ?
………………
………………………………..

La commande read peut être utilisée pour réaliser une pause dans un programme en demandant à l’utilisateur d’appuyer sur la touche pour continuer. Ici, on ne souhaite pas récupérer la saisie dans une variable puisque cette dernière ne sera pas utilisée. Inutile dans ce cas de gaspiller de la mémoire, on ne précise pas de nom de variable :

echo « Appuyer sur pour continuer… » read

04 ► EXÉCUTER DES COMMANDES SUIVANT DES CONDITIONS PRÉCISES.

Dans un script, il se peut que l’on veuille effectuer des actions différentes en fonction d’une valeur calculée ou transmise par l’utilisateur. Par exemple, à la question « Voulez-vous quitter le programme (O/N) ?« , il est bien évident que l’action à déclencher sera différente suivant que l’utilisateur réponde par l’affirmative ou la négative. Grâce aux structures conditionnelles nous allons pouvoir gérer ces cas.

01 ) La construction des structures conditionnelles.

Pour conditionner l’exécution de lignes de code, on utilise l’instruction if, qui se traduit par « si » et qui s’écrit de la manière suivante :

if condition; then    … fi

Les lignes encadrées par la ligne if et la ligne fi (if à l’envers) forment ce que l’on appelle « un bloc » : elles seront toutes exécutées (ou aucune) suivant que la condition du test soit vérifiée ou non. Le caractère point-virgule, qui suit la définition de la condition à vérifier, permet de séparer plusieurs commandes sur une même ligne.

L’instruction then (qui signifie « alors« ) étant une nouvelle instruction, il faut la séparer du début de ligne par un point-virgule. Sans ce caractère, il aurait fallu utiliser une notation moins compacte :

if condition then    … fi

Cette structure permet donc d’exécuter des instructions au cas où la condition est vérifiée. Dans le cas où elle est invalidée, si vous souhaitez effectuer un autre traitement, il faudra utiliser l’instruction else dans une structure « si condition alors … sinon … » :

if condition; then … else    … fi

Enfin, on peut imbriquer les tests dans des structures de type « si condition_1 alors … sinon, si condition_2 alors sinon, si … ect. » :

if condition_1;   then     … elif condition_2;   then     … elif   …ect…     … fi

Nous avons vu la syntaxe permettant d’écrire des structures  contenant des embranchements s’activant en fonction de conditions …Il reste donc à voir comment écrire une condition pour pouvoir réellement utiliser ce mécanisme.

Une condition, encore appelée test, peut s’écrire de deux manières différentes :

► soit en l’encadrant par des crochets […]
► soit en utilisant la commande test …

Une fois la syntaxe choisie, en conjuguant cette écriture avec un opérateur de test, on obtient une condition. Avec des nombres par exemples, les opérateurs de test permettront d’écrire « Est-ce que a est plus petit que b ?« . L’opérateur « plus petit que » s’écrit -lt .

Voici un exemple de condition où nous employons les deux syntaxes décrites précédemment :

[ 2 -lt 3 ]
test 2 -lt 3

Ces deux lignes sont identiques et testent si 2 est inférieur ou égal à 3. Dans tout test, une condition vérifiée renverra 0 et sinon, un entier quelconque différent de 0. Si vous voulez vous en assurer, vous pouvez afficher le contenu de la variable spéciale $? après avoir exécuté un test :

~$ [2 -lt 3 ]
~$ echo $?
0

Si le nombre d’arguments est inférieur à 2 (ligne 3), alors on affiche un message d’erreur (ligne 4) et sinon, on affiche le nombre d’arguments (ligne 6).

02 ) Les opérateurs test.

Les opérateurs de test se répartissent en trois catégories : les opérateurs arithmétiques dont nous avons pu voir un exemple avec -lt, les opérateurs de test de fichiers, et les opérateurs logiques permettant de créer des conditions complexes.

02.1 – Les opérateurs arithmétiques :

L’opérateur arithmétique -lt, que nous avons déjà vu, signifie « low than » soit « inférieur à« ; Les autres opérateurs sont construits sur le même modèle : -gt pour plus grand que (greater than), -eq pour égal (equal), -ne pour différent de (not equal), -ge pour plus grand ou égal à (greater or equal), -le pour plus petit ou égal à (lower or equal).

Sachez que ces opérateurs sont des opérateurs arithmétiques et fonctionnent donc avec des nombres. Si vous voulez effectuer des tests sur des chaînes de caractères, vous devrez utiliser des opérateurs différents : == pour l’égalité et != pour la différence.

02.2 – Les opérateurs de test de fichiers :

Les opérateurs de test de fichiers permettent d’obtenir très facilement des informations sur les fichiers. Il s’agit la plupart du temps d’opérateurs unaires portant sur le nom d’un fichier. Voici quelques-uns de ces opérateurs :

► -e : pour vérifier l’existence d’un fichier (exists).
► -f : pour vérifier l’existence d’un fichier et qu’il s’agisse bien d’un fichier et pas d’un répertoire par exemple (file)
► -d : pour vérifier l’existence d’un répertoire (directory).
► -r : pour vérifier si un fichier est accessible en lecture (readable).
► -w : pour vérifier si un fichier est accessible en écriture (writable)
► -x : pour vérifier si un fichier a les droits d’exécution (executable).

02.3 – Les opérateurs logiques :

Les opérateurs logiques permettant de composer des conditions plus « complexes » à l’aide des opérateurs booléens « et« , « ou » et « non« .

L’opérateur « non » est un opérateur unaire : il n’accepte qu’un seul argument dont il va inverser la valeur retour . Si une conditions est vraie, alors elle sera fausse et inversement. Le symbole de cet opérateur est !.

Si vous voulez tester si 10 est supérieur ou égal en 5 en ne connaissant que l’opérateur -lt (inférieur à), il faudra prendre la négation de la condition : [ ! 10 -lt 5 ].

Les opérateurs « et » et « ou » sont des opérateurs binaires permettant de composer des conditions « si condition_1 est vraie et/ou si condition_2 est vraie, alors …« . On utilise && ou -a pour l’opérateur « et » et || ou -o pour l’opérateur « ou« . Ces opérateurs peuvent être combinés à l’infini.

Pour tester si une variable var est comprise entre 1 et 10, on utilisera le test :
[ $var -ge 1 ] && [ $var -le 10 ].

Enfin, une commande permet d’obtenir la liste complète des opérateurs arithmétiques, de test de fichiers et logiques disponibles pour la création de conditions :

~$ info coreutils ‘test invocation’

03 ) La structure case .

Il n’existe pas que l’instruction if pour créer des structures conditionnelles : pour les structures à choix multiples, il existe la structure case permettant d’effectuer un branchement sur des lignes de codes en fonction de la valeur contenue dans une fonction.

On peut voir cette structure comme un grand aiguillage ferroviaire, dont le numéro de voie est donné par le contenu d’une variable. Au niveau syntaxique, la valeur de la variable pour chaque cas possible sera suivie d’une parenthèse fermante et le bloc d’instructions à exécuter pour ce cas se situera entre la parenthèse fermante et les caractères ;; (une instruction vide signifiant la fin du bloc).

Appliquons cette définition à un exemple : la variable choix peut valoir 1,2,3 ou 4 et l’action à effectuer sera simplement d’afficher le chiffre correspondant en toutes lettres pour les valeurs 1 à 3 et d’afficher le message « coucou » pour la valeur 4. Dans tous les autres cas, nous afficherons un message d’erreur.

Voici le code correspondant à cet exemple :

#!/bin/bash echo « Donnez un chiffre entre 1 et 4 : » read choix case $choix in 1)   echo   « un »;; 2)  echo   « deux »;; 3)  echo    « trois »;; 4)  echo    « coucou »;; *)  echo    « ERREUR ! » esac

Le dernier cas, en ligne 11, correspond au choix par défaut : si l’utilisateur saisit autre chose qu’un entier entre 1 et 4, c’est cette action qui sera effectuée. L’utilisation du caractère * pour indiquer tous les cas différentes de ceux traités (on dira « filtrés« ) auparavant, vient du fait qu’il s’agit en fait d’expressions régulières. En ligne 12, on referme le bloc case en inscrivant le nom de l’instruction à l’envers : esac .

04 ► EXÉCUTER PLUSIEURS FOIS UNE COMMANDE SANS AVOIR À LA RÉ-ÉCRIRE.

Une boucle permet de répéter une action , une commande ou un bloc de commandes un certain nombre de fois. Ces commandes pourront être exécutées à l’identique ou paramétrées à l’aide de variables qui évolueront à chaque passage dans la boucle. Si vous voulez afficher les 100 premiers résultats de la table de multiplication par 7, vous n’allez certainement pas écrire 100 lignes de code et calculer « à la main » les résultats ! D’où l’intérêt des boucles …

01 ) Les structures de base.

Le shell propose deux structures de boucles « simples » dont le fonctionnement général est identique : un bloc de commandes va être exécuté jusqu’à ce qu’une condition change d’état.

01.1 – L’instruction « while » :

La première des structures de boucle est composée à l’aide de l’instruction while et signifie « tant que la condition est vérifiée, faire…« .

Dans le cas proposé en exemple, l’écriture des cents premiers résultats de la table de multiplication par 7, nous allons avoir besoin d’une variable i qui sera incrémentée et sera multipliée par 7 à chaque étape. La condition sera donc : « tant que i est inférieur ou égal à 100, faire…« . La traduction en script shell donne :

#!/bin/bash i=1 while [  $i -le 100 ];  do               echo  $i« *7= »$(($i*7))               i=$(($i+1)) done

En ligne 3, nous commençons par initialiser une variable i avec la valeur 1. Cette variable va nous permettre de compter de 1 à 100 pour effectuer nos calculs. Ce décompte va être contrôlé par la condition d’arrêt de notre boucle en ligne 5, qui peut être traduite par « tant que i est inférieur ou égal à 100, faire » . Vous reconnaîtrez dans l’écriture de la condition la syntaxe que nous utilisons avec les structures conditionnelles. Nous pouvons ensuite réaliser l’afficher en ligne 6 et surtout, ne pas oublier d’incrémenter la variable de boucle en ligne 7, de manière à pouvoir sortir de la boucle à un moment donné.

01.2– L’instruction « until » :

La deuxième structure de boucle est la structure until, qui se rapproche énormément de la boucle while… à la différence prêt que la condition d’arrêt n’est pas interprétée de la même manière. En effet, until signifie « jusqu’à ce que… » et la boucle sera donc exécutée jusqu’à ce que la condition soit vérifiée (au contraire de la boucle while qui s’exécute tant que la condition est vérifiée).

Reprenons l’exemple utilisé précédemment avec le while : vous constaterez qu’une ligne sera modifiée. Mais attention : la condition a été inversée ! On passe ainsi de « tant que i < 100 » à « jusqu’à ce que i > 100« .

#!/bin/bash i=1 until     [ $i -gt 100 ]; do               echo  $i« *7= »$(($i*7))               i=$(($i+1)) done

02 ) Parcourir une liste.

Le shell propose des instructions permettant de parcourir simplement une liste.

02.1 – L’instruction « for » :

Cette structure s’éloigne un peu des deux types de boucles vus précédemment : ici, nous allons parcourir une liste d’éléments (chaînes de caractères, entiers ou mélange de plusieurs types). Une liste est spécifiée par une suite d’éléments séparés par un espace.

Voici un exemple de liste :

« chaîne » 1 2 « autre chaîne » 3 4 5

L’utilisation du caractère * permet d’obtenir un élément de type liste : les fichiers du répertoire courant. Il s’agit d’un joker qui peut être également combiné avec d’autres caractères *.py renverra par exemple la liste des fichiers Python du répertoire courant,  script* renverra  la liste des fichiers dont le nom commence par « script ». Pour parcourir les fichiers d’un répertoire, vous pourrez donc utiliser for en association avec le caractère *.

La construction de la boucle se fait à l’aide d’une variable qui va prendre consécutivement pour valeur les éléments de la liste. La syntaxe sera la suivante : for variable in liste; do que nous pourrions traduire par « pour la variable nommé variable prenant ses valeurs dans la liste, faire…« . N’oubliez pas que lors de l’utilisation de la variable, il faut préfixer son nom par la caractère $.

Voici par exemple comment afficher et compter les fichiers du répertoire courant à l’aide de cette structure :

#!/bin/bash i=1 for file in *; do           echo $i« . « $file           i=$(($i+1)) done

En ligne 5, le caractère * va être remplacé par la liste des fichiers. À chaque itération, la variable file va changer la valeur et contenir le nom d’un des fichiers du répertoire courant. Donc, à la première itération, $file désignera le premier fichier, puis à la deuxième itération, le deuxième fichier, et ainsi de suite.

02.2– L’instruction select pour une boucle un peu particulière :

L’instruction select est une sorte d’amélioration du for pour des cas particuliers. En effet, elle permet de proposer à l’utilisateur de saisir un choix dans une liste qui sera affichée à l’écran. Sans commande d’arrêt (que nous verrons par la suite), la demande saisie sera infinie.

Voici un exemple simple :

#!/bin/bash select choix in « entrée 1 » « entrée 2 » ; do          echo « Vous avez choisi » $choix done

Lors de son exécution, ce script va réaliser l’affichage suivant :

Vous pourrez saisir votre choix après le point d’interrogation et la variable choix prendra pour valeur votre saisie (à condition que cette dernière fasse partie des choix possibles ; (1 & 2)).

Attention: vous devez taper le numéro correspondant à votre choix et la variable choix ne contiendra pas ce numéro mais le contenu correspondant à cet indice !

Comme dit précédemment, ce script boucle à l’infini et demandera toujours à l’utilisateur de saisir un choix. Pour arrêter la boucle, il faut utiliser break.Le menu ressemblera alors à:

#!/bin/bash select choix in « entrée 1 » « entrée 2 » « q »; do                   case $choix in              « entrée 1 » | « entrée 2 ») echo « Vous avez choisi » $choix;;             « q ») echo « Au revoir… »                   break;;              *) echo « Saisie non valide ! »                     esac done

Ainsi, avec ce genre de structure, on assure que la boucle sera exécutée tant que l’utilisateur ne saisit pas un choix valide et que le menu sera ré-affiché jusqu’à ce que l’utilisateur sélectionne le choix 3 (test de la ligne 6 et sortie de la boucle select par le break de la ligne 7). Si vous souhaitez également interrompre la boucle dès qu’un choix valide a été sélectionné, vous pouvez également utiliser des break.

Créer une structure équivalente à l’aide des instructions for et while serait légèrement plus complexe :

i=1 for choix in « entrée 1 » « entrée 2 » « q » ; do               echo $i« ) » $choix              i=$(($i+1)) donewhile [ 1 ]; do                    echo -n « #? «                     read choix                    case $choix in                    1 | 2) echo « Vous avez choisi l’entrée n. » $choix;;                    3) echo « Au revoir… »                             break;;                    *) echo « Saisie non valide ! »               esac done

 

Il faut commencer par afficher les choix possibles (ligne 1 à 5), puis rentrer dans une boucle infinie en ligne 7 dont la condition d’arrêt est [ 1 ] (qui est toujours vrai) et enfin, demander à l’utilisateur de saisir un choix (notez l’usage de l’option -n de echo en ligne 8 pour désactiver le retour chariot) et traiter ce choix. Comme ici il n’y pas de correspondance entre le numéro saisi et la valeur du choix, nous récupérons dans la variable $choix que le numéro saisi. Dans ce cas particulier, il est donc bien plus pratique d’utiliser l’instruction select !

CHOSES À RETENIR ET ASTUCES :

► Un éditeur de texte ne sauvegarde que le texte tapé au clavier. Un logiciel de traitement de texte tapé au clavier, ainsi que sa mise en forme (police, style, ect.).

► Dans les éditeurs de texte, la coloration syntaxique ne s’active en général qu’une fois le fichier enregistré avec la bonne extension (.sh pour les scipts shell).
Commencez donc par enregistré votre fichier avant de taper la moindre ligne de code !

► Les caractères #! sur la première ligne d’un fichier indiquent au système que ce fichier est un script qui doit être interprété par le programme indiqué à la suite sur cette même ligne, appelée « shebang »
À la lecture de la ligne #!/bin/bash, le système va exécuter la commande /bin/bash et lui fournir en entrée de lignes suivantes du fichier.

► Pensez à commenter abondamment vos lignes de code ! Elles vous semblent évidentes au moment où vous les écrivez, mais si vous devez relire votre programme plus tard, elles vous paraîtront nettement moins compréhensibles.

► Comme le shell est sensible à la case (différence majuscules/minuscules), il est d’usage de n’utiliser que des caractères minuscules pour nommer ses variables. Les noms en majuscules sont réservés aux variables d’environnement.

► PASSER DES ARGUMENTS À UN SCRIPT :
Les variables spéciales $1, $2, … $n permettent de récupérer les arguments transmis à un script lors de son appel. La correspondance entre les noms de variables et les arguments se fait en fonction de la position de ces derniers :
~$ monScript.sh argument1 argument2 argument3 s0 s1 s2 s3

► LES DANGERS DE LA COMMANDE READ :
En employant la commande read suivie de plusieurs noms de variables, vous pourrez récupérer plusieurs valeurs saisies par l’utilisateur, le caractère espace faisant office de délimiteur. Mais attention ! Si l’utilisateur donne plus de valeurs que ce qu’il n’y de variables dans la commande read, votre dernière contiendra tous les caractères restants. Voici un petit exemple illustrant le principe :
~$ echo « Saisir a et b: »; read a b; echo « a = » $a « et b = » $b GNU/Linuxiens a = GNU/ et b = Linuxiens
~$ echo « Saisir a et b: »; read a b; echo « a « et b= » $b GNU/Linuxiens test de variables a = GNU/Linuxiens et b = test de variables

► ATTENTION AUX ESPACES !
Lors de l’écriture de conditions en la syntaxe […], faites très attention à bien laisser un caractère espace après le crochet ouvrant et avant le crochet fermant :
~$ [2 -lt 3]
[2 : commande introuvable
~$ [ 2 -lt 3]
bash: [:  » ]  » manquant
~$ [ 2 -lt 3 ]
La dernière ligne ne renvoie pas d’erreur et fonctionne donc correctement.

► Chaque passage dans une boucle s’appelle une itération et si la condition d’arrêt porte sur une variable, cette dernière se nomme variable de boucle.
Il faut faire très attention à ce que la condition d’arrêt de la boucle puisse changer d’état à un moment donné, sinon votre script rentrera dans une boucle infinie et vous ne pourrez l’arrêter qu’à l’aide de [Ctrl]+[C]. Ce genre de condition dépend en général d’une variable de boucle qu’il faudra prendre soin de faire évoluer au cours des itérations (soit en l’incrémentant, soit en la décrémentant.)

► À chaque fois que vous utilisez le caractère * dans une commande shell, celui-ci est remplacé par la liste des fichiers du répertoire courant. Par exemple, si votre répertoire contient trois fichiers : monFichier.txt ; monTest.sh et monTest.py, le caractère * dans une commande sera remplacé par la liste de ces fichiers :
~$ echo mo*
monFichier.txt monTest.sh monTest.py

Voilà, nous en avons terminé pour cette quatrième parties.

La cinquième parties sera accès sur la recherche de fichier, la gestion des utilisateurs, la gravure et l’encode de CD/DVD et il y aura une partie sur le réseau (interfaces, SSH, bureau à distance-graphique, partage de fichiers et la sauvegarde de données.)

À très vite … Merci.

À découvrir dans cette partie …..
(au passage, merci car vous êtes de plus en plus nombreux à me lire et donc, je l’espère pour certains, à se lancer enfin dans le monde du logiciel libre et de Linux).

Toutes les commandes de base pour manipuler ses fichiers.
Lorsque l’on s’initie à la ligne de commandes, il est nécessaire de commencer par les commandes incontournables, à savoir celles qui sont liées à des tâches courantes comme la création de fichiers ou de répertoires, la copie ou la suppression de fichiers, l’accès au contenu d’un fichier, mais aussi toutes les commandes qui permettent de se déplacer rapidement dans l’arborescence de votre système. Vous trouverez donc ici le récapitulatif des principales commandes à connaître pour bien débuter.

Pour se familiariser avec la ligne de commandes, rien de tel que d’effectuer quelques opérations simples sur les fichiers et répertoires, histoire de bien maitriser son environnement, de pouvoir se balader dans son système de fichiers et d’organiser ses documents en toute facilité.

01 ► NAVIGUER PARMI SES FICHIERS :

1.1 ) Chemin absolu ou relatif ?

Pour indiquer un fichier au shell, sachez que son nom seul ne suffit pas… À moins de se trouver dans le même répertoire que le fichier en question.

La référence exacte à un fichier est appelée « chemin » (c’est en quelque sorte son adresse, son emplacement dans le système) ; il indique précisément dans quel répertoire se trouve le fichier. Sous Linux, les noms des répertoires et des fichiers au sein d’un chemin sont séparés par un slash / (contrairement aux systèmes Windows, où le séparateur est un anti-slash \).

Notez que plusieurs fichiers peuvent porter le même nom, du moment qu’ils ne se situent pas à la même adresse (même répertoire donc) .

On distingue ainsi deux types de chemins :

=> un chemin absolu prend pour référence le début de l’arborescence de fichiers, à savoir la racine ; il commence donc toujours par le symbole / .

=> un chemin relatif dépend du répertoire courant où se trouve l’utilisateur au moment où il fait référence au fichier.

Considérons par exemple le schéma du dessus avec quelques rajouts logique. Si l’on souhaite faire référence au fichier de chemin absolu /home/marc/Musique/rock/track1.mp3 alors que l’on se situe dans le répertoire /home/marc/Images/ ,on fera appel au chemin relatif suivant : …/Musique/rock/track1.mp3 .

Si, alors qu’il se situe dans le répertoire Images/, Marc saisit la commande suivante :

~/Images$ rythmbox track1.mp3

Le système répondra que le fichier n’existe pas (car aucun fichier du nom track1.mp3 ne se trouve dans le répertoire courant qui est Images/ ).

En revanche, si Marc se trouve dans le répertoire rock/ et qu’il souhaite écouter le fichier track1.mp3, il peut tout à fait saisir son nom seul ici, puisque relativement, il n’y a que cette possibilité.

~/rock$ rythmbox track1.mp3

1.2 ) Mais …où suis-je ?

Pour connaître à tout moment le chemin absolu du répertoire où l’on se situ, il suffit de saisir la commande pwd (print working directory).

À savoir que par défaut, le terminal que vous utilisez s’ouvre toujours sur votre répertoire personnel à son lancement.

Pour se déplacer d’un répertoire à un autre on utilise la commande cd (change directory) suivie du nom (ou du chemin) du répertoire de destination :

~$ cd /home/linuxfrench/

Pour vous rendre dans votre répertoire personnel, quel que soit l’endroit où vous vous situez, vous pouvez saisir simplement :

~$ cd ~
(ou créer un alias comme vu dans la deuxième partie de cette série d’article « lignes de commandes« . => alias cdd=’cd ~’ *wink*)

Le symbole ~ remplace en effet le chemin absolu vers votre répertoire personnel. Mais on pourra saisir simplement :

~$ cd

Et pour revenir au répertoire précédent, on utilise le tiret, comme ceci :

~$ cd –
ou alors :
~$ cd ..

02 ► CRÉER ET SUPPRIMER UN RÉPERTOIRE :

Ce n’est pas plus compliqué que d’effectuer un clic droit dans votre navigateur de fichiers graphique ! La création d’un répertoire se fait avec la commande mkdir (make directory), suivie du nom du répertoire à créer. Le répertoire est alors crée dans le répertoire courant :

~$ mkdir Dossier

Pour créer un répertoire et se sous-répertoires simultanément, on ajoute l’option -p :

~$ mkdir -p Dossier/SousDossier1/sousdossier2

La suppression d’un répertoire vide s’effectue avec la commande rmdir (remove directory). Si le répertoire n’est pas vide, le système refuse de vous obéir :

~$ rmdir tests/

L’option -p permet de supprimer le répertoire ciblé, ainsi que son (ou ses) répertoire(s) parent(s). Ainsi, la commande :

~$ rmdir -p Dossier/tests

va supprimer non seulement le répertoire tests/ mais aussi le répertoire Dossier/ par la même occasion.

À savoir que la commande rm, qui permet de supprimer des fichiers (comme nous allons le voir ci-après), utilisée avec l’option -r permet également de supprimer un répertoire et son contenu de façon récursive, autrement dit la suppression concerne également les sous-répertoires :

~$ rm -r tmp/

Et si vous ajoutez l’option -f, les fichiers protégés en écriture seront également supprimés, sans vous demander la moindre confirmation :

~$ rm -rf tmp/

(ne tapé cette commande sous aucun prétexte !!! À utiliser avec précautions !)

03 ► JONGLER AVEC SES FICHIERS :

03.1 ) Créer, déplacer et supprimer des fichiers.

La copie des fichiers s’effectue via la commande cp (copy). On l’utilise en respectant la syntaxe suivante :

~$ cp <fichier(s)_à_copier> <répertoire_de_destination>

Par exemple :

~$ cp photo1.jpg photo2.jpg photo3.jpg mes_images/

Remarquez au passage que nous pourrions ici simplifier la commande en utilisant un métacaractères comme évoqués dans l’article précédent. En effet, si nous souhaitons copier l’ensemble des fichiers d’extension .jpg, nous pourrions écrire :

~$ cp *.jpg mes_images/

Rappelons que le caractère * remplace zéro, un ou plusieurs caractère(s).

Par ailleurs, il est possible de copier tout un répertoire de façon récursive en ajoutant l’option -r :

~$ cp -r <répertoire(s)_à_copier> <répertoire_de_destination>

Le déplacement de fichiers et de répertoires s’effectue avec la commande mv (move) :

~$ mv <fichier/répertoire_à_déplacer> <répertoire_de_destination>

mv peut également être utilisé pour renommer un fichier ; dans ce cas, elle prend en paramètre le nom du fichier en question, suivi de son nouveau nom :

~$ mv document.txt contrat.txt

Enfin, pour supprimer un fichier, on utilise la commande rm (remove) suivie du nom du fichier concerné :

~$ rm <fichier_à_supprimer>

Comme on l’a vu plus haut dans le cas des répertoires, l’option -f permet de supprimer les fichiers protégés en écriture sans pour autant avoir à confirmer cette action.

Et pour supprimer tout le contenu d’un répertoire (fichiers et sous-répertoires y compris), on se positionne dans ledit répertoire et on exécute :

~$ rm -rf *

03.2 ) Une alternative à la copie : le lien symbolique.

Pour simplifier la gestion des fichiers, il peut parfois s’avérer utile de créer ce que l’on appelle un lien symbolique. Un lien symbolique contient le nom d’un fichier, ou plus exactement, le chemin vers ce fichier. Il joue ainsi le rôle de pointeur vers ce dernier.

Vous l’aurez compris, la création d’un lien permet d’éviter la copie physique d’un fichier si l’on souhaite en disposer à plusieurs endroit de l’arborescence .

Pour créer un lien, on utilise la commande ln ; l’option -s permet d’indiquer qu’il s’agit d’un lien symbolique. La syntaxe est la suivante :

~$ ln -s

Notez que lors de la création d’un lien symbolique, l’existence du fichier lié n’est pas vérifiée, c’est donc à vous d’être vigilant sur ce point ; s’il n’existe pas, le lien ne fonctionnera pas, tout simplement.

Considérons un exemple concret : après avoir téléchargé, puis lancé le fichier binaire (l’exécutable) d’un quelconque logiciel, vous constatez que le processus d’installation automatiquement a positionné l’exécutable exec dans le répertoire /opt/Editeur/Nom/bin/exec .Ce qui n’est guère pratique pour l’utiliser, car ce chemin n’étant pas défini dans la variable $PATH, il faudra systématiquement spécifier tout son chemin d’accès pour l’utiliser …

Nous allons donc créer un lien symbolique vers le fichier exécutable qui nous intéresse (il s’agit d’un script Bash nommé « auto-pass-generate.sh« , qui génère des mots de passe aléatoire de la taille et difficulté que vous voulez) que « j’ai crée ». Au passage, je pense d’ailleurs que la création de script Bash (.sh) ça sera la prochaine aventure que je vous ferais suivre après avoir fini avec le sujet « la ligne de commande ») … Oula ! Ça fait un peu-beaucoup de parenthèse tout ça. Je reprend :

Nous allons donc créer un lien symbolique vers le fichier exécutable qui nous intéresse dans un répertoire qui lui, est défini dans $PATH :

~$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin/:/usr/bin/:/bin/sbin/:/sbin/bin/
~$ ln -s /opt/Editeur/Nom/bin/exec /usr/local/bin/exec
~$ ls -l /usr/local/bin/*.sh

À présent, il est possible maintenant de lancer la commande exec (auto-pass-generate.sh) depuis n’importe quel endroit de l’arborescence de fichiers ; le système saura retrouver le fichier exécutable correspondant grâce à la création du lien symbolique précédent.

(bon, après c’est vrai qu’il est possible de faire ça de manière plus simple en copiant n’importe quel exécutable pris en charge par votre terminal dans le répertoire /bin . Mais il reste important de connaître et de maitriser la création de lien symbolique).

04 ► LIRE OU ÉTUDIER LE CONTENU D’UN FICHIER :

Pour simplement visualiser le contenu d’un fichier (sans possibilité d’édition, trois commandes sont à retenir : cat, more et less .Il suffit de les faire suivre du nom (ou du chemin) du fichier qui vous intéresse .

-> cat affiche tout le contenu du fichier dans le terminal et vous rend la main immédiatement ;

-> more permet de visualiser le contenu du fichier page-par-page ; on passe d’une page à l’autre à l’aide de la touche [Espace] ;

-> less, à la différence de more, ne charge pas le fichier dans son intégralité avant de commencer à l’afficher ; c’est pourquoi il est préférable d’utiliser less plutôt que more dans le cas de gros fichiers.

Si seul le début ou la fin d’un fichier vous intéresse, vous pouvez utiliser les commandes suivantes :

~# head /var/log/messages

(affiche les 10 premières lignes du fichier /var/log/messages )

~# tail /var/log/messages

(affiche les 10 dernières lignes du fichier /var/log/messages)

Dans les deux cas, on peut utiliser l’option -n pour définir un nombre de ligne différent de 10 :

~# tail -n 30 /var/log/messages

Très utile également, l’option -f (follow) qui permet de passer en mode « attente » :

~# tail -f /var/log/messages

Les 10 dernières lignes du fichiers sont affichées, puis dès qu’une nouvelle donnée est inscrite dans le fichier, elle est retranscrite immédiatement à l’écran. Le raccourci [Crtl]+[C] permet de quitter ce mode et de reprendre la main.

La commande nl permet d’afficher le contenu du fichier passé en argument en ajoutant la numérotation des lignes. Pour spécifier un séparateur d’affichage entre le numéro de la ligne et la ligne elle-même, il est possible d’utiliser l’option -s, suivie du caractère séparateur entre guillemets, comme suit :

~# nl -s « : » /var/log/messages | tail
6584:Feb     5 ….
[…]
…………..
……………………..
[…]

La commande file permet de lire le début d’un fichier pour en déterminer le type de contenu ; elle nécessite bien entendu d’avoir le droit de lecture sur le fichier concerné. Exemples :

~$ file fichiers_video.avi
fichiers_video.avi : RIFF …….
[….]

~$ file un_document
un_document :  ASCII text, with very long lines

Pour la comparaison de fichiers, on retiendra les commandes cmp, et diff. La commande cmp permet de comparer le contenu de deux fichiers en précisant la position de la première différence relevée :

~$ cmp fichier.txt fichier2.txt
fichiers1.txt fichier2.txt sont différents :  octet 14, ligne 3

Comme vous vous en doutez, si la commande ne retourne rien, c’est que les deux fichiers sont rigoureusement identiques.

La commande diff, de son coté, permet de comparer le contenu de deux fichiers ou répertoires et dresse la liste de toutes les différences relevées.

Dans un autre registre, la commande touch permet de modifier la date d’accès et la date de modification de chaque fichier passé en argument.

Par défaut, ces horodatages sont remplacés par la date et l’heure courantes, mais l’option -t suivie d’une date au format MMJJhhmm (mois, jour, heures, minutes) permet d’utiliser cette dernière à la place de la date courante :

~$ ls -l
-rw-r–r–   1   user  user    1038819     5 nov.   16:36  mycapture

~$ touch -t 02162340 mycapture && ls -l
-rw-r–r–   1   user  user    1038819     16 feb.    23:40  mycapture

Toutes ces commandes constituent déjà un bel éventail de base pour vous entrainer à la ligne de commandes. Créez, déplacez, renommez, supprimez !
N’hésitez pas à faire un maximum de tests jusqu’à ce que vous vous sentiez aussi à l’aise qu’en utilisant votre interfac graphique. Bientôt, celle-ci ne sera plus qu’un souvenir lointain tellement vous trouverez votre terminal bien plus rapide.
Et là, vous vous direz, « mais pourquoi ai-je tant attendu ?! »

► Préparez vous bien en tout cas car dans le 4ème article, nous parlerons,créerons et exécuterons des « scripts shell« .

Je vous dit à très vite alors ….