[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]

Nous stockons de nombreuses informations, pour beaucoup sensibles, et 
dans des formats différents. Cela fait autant de mots de passes à créer,
à retenir et à utiliser. À utiliser. À utiliser pour souvent 
quotidiennement, il faut donc leur utilisation soit la plus transparente 
possible soit la plus transparente possible et s'adapte aux différents 
services cleints : données sur une partition chiffrée, site internet, 
client d'une application bancaire. Application en ligne de commandes. 
Vous utilisez peut être déjà une extension Web pour les sites Web : 
c'est bien, mais cela ne gére pas une société tierce sur leurs serveurs 
lorsque vous rentrez dans l'extension. Dans cet article, nous allons 
découvrir KeepassXC, un gestionaire de mots de passe libre qui vous 
permettra de répondre à tous types de besoins et de ne pas partager 
vos mots de passe avec une société tierce.

Benoît Benedetti

Introduction :

À l’origine, il y avait Keepass, un très bon gestionnaire de mot de passe libre, seulement disponible sur Windows. Puis est arrivé KeepassXC (avec X comme croix, cross en anglais pour cross-platform/multiplateforme), un fork de Keepass pour le porter sur plusieurs plateformes et ajouter de nouvelles fonctionnalités. Malheuresement, le développement de KeePassX a commencé à s’éssouffler et s’est carrément arrêté en 2016. Des dééveloppeurs ont crée un nouveau projet plus dynamique : KeepassXC est né. Bien que KeePass n’ait pas ralenti son développement, KeePassXC reste la meilleure alternative des gestionnaires de mot de passe. Il est libre, a une communauté active, est plus simple à utiliser, et a pus de fonctionnalités :

• multiplateforme Linux, MacOS et Windows
• compatible avec KeePass, KeePassXC, MacPass
• chiffrement de la base de données en AEs 256 bits
• auto-remplissage des formulaires de connexion
• client en ligne de commandes
• intégration avec les navigateurs Web
• import / export des mots de passes
• générateur de mot de passe et de passphrases
• partage et fusion de bases de mot de passe
• https://keepass.info/help/base/index.html
  

Installation

KeePassXC est disponible sur toutes les distributions Linux, généralement la version 2.4.3, largement récente pour profiter de ses fonctionnalités, que vous pouvez installer simplement sous Debian et dérivées avec la commande :

$ sudo apt install keepassxc

La dernière version stable de KeePassXC est là 2.5.0 sortie en automne 2019. C’est elle que j’utiliserai dans cet article. Pour installer simplement, vous pouvez la récupérer au format AppImage depuis le site officiel. AppImage est un exécutable portable qui peut-être lancé tel quel sur n’importe quelle distribution Linux récente. On commence par récupérer KeePassXC au format AppImage et lancer l’application avec la commande ci-dessous :

$ sudo wget https://github.com/keepassxreboot/keepassxc/releases/download/2.5.0/KeePassXC-2.5.0-86_64.AppImage -O /usr/local/bin/keepassxc

$ sudo chmod a+x /usr/local/bin/keepassxc
$ sudo keepassxc &

On va créer un lanceur pour intégrer cette AppImage au bureau Gnom, afin de ne pas à avoir à passer par la ligne de commande pour utiliser KeePassXC.
Créez le fichier suivant :

$ nano ~/.local/share/application/appimagekit-keepass.desktop

[Desktop Entry]
Name=KeePassXC AppImage
GenericName=Password Manager
GenericName[fr]=Gestionnaire de mot de passe
Comment=Community-driven port of the Windows application "KeePass Password Safe"
Exec=keepassxc %f
TryExec=Keepassxc
StartupWMClass==keepassxc
Terminal=false
Type=application
Version=1.0
Categories=Utility;Security;Qt;

Vous pouvez désormais lancer la version 2.5.0 de KeePassxc au format AppImage comme n’importe quelle application graphique de bureau depuis votre lanceur d’application GNOME.

Démarrage et initialisation d’une base de mots de passe

Comme on peut le voir au lancement de l’application, celle-ci nous propose soit d’importer vos mots de passe depuis une autre applications ou d’ouvrir une base de données existante.Étant donné que nous partons de zéro, nous allons cliquer sur le bouton pour créer une nouvelle base de données dans laquelle stocker nos mots de passe. Un assistant de création vous demande d’abord de donner un nom à cette base : vous pouvez très bien créer une seule base qui va contenir tous vos mots de passe, ou bien créer plusieurs bases pour éviter de mélanger vos mots de passe personnels et professionnels, choisissez donc un nom pertinent pour votre base. Puis un autre écran vous demande les paramètres de chiffrement, vous pouvez tout à fait laisserceux par défaut. Ensuite, il faut protéger votre base avec au minimum un mot de passe à retenir, demandé lors de l’ouverture de la base, ne perdez donc pas ce mot de passe. En cliquant sur « Ajouter une protection supplémentaire .. » vous pourrez protéger votre base avec un keyfile (un fichier nécessaire pour ouvrir la base en plus du mot de passe maître, à ne pas perdre) et/ou avec une clé Yubikey. Enfin, choisissez un emplacement pour stocker votre base : je la stocke dans mon dossier Nextcloud, synchronisé entre mes différentes machines, car pour avoir avoir un code plus simple et ne pas forcer leurs utilisateurs avec une solution de synchronisation maison, les développeurs de KeePassXC ne proposent pas de mécanismes de synchronisation. J’ai aussi stocké le fichier dans un dossier caché au nom peut évocateurt « misc » , fichier de base de données qui est lui même un fichier caché nommé « perso » : ce n’est pas ça qui arrêtera quelqu’un qui veut vraiment pirater mes données, mais ce n’est pas plus cher et ça ne mange pas de pain, alors autant le faire.

Voilà, votre base est créee, vous revenez à l’interface de KeePassXC, cette base de données ouverte et déverrouillée, vide, mais prête à être utilisée. De là vous pouvez fermer la base, en créer ou en ouvrir une autre. Désormais, si vous fermez KeePassXC, la fenêtre de lancement va être différente, il vous sera proposé par défaut d’ouvrir la dernière base utilisée, à déverrouiller à l’aide de son mot de passe maître.

Ajouter une entrée identifiant / Mot de passe dans votre base

Maintenant que nous avons une base, ajoutons-y des mots de passe. Pour cela, on crée depuis l’interface de KeePassXC une entrée. Une entrée est une entité qui contient toutes les informations d’accès à un service : un site web, une application, un réseau (VPN, WIFI, …) un ordinateur, ect. Ces informations sont un nom, titre, un identifiant de connexion, un mot de passe,l’adresse du site, ect

Pour créer une entrée, cliquez sur l’icône sous forme de clé, ou depuis le menu « Entrée », sélectionnez « Nouvelle Entrée », la page d’édition d’une entrée apparaît. Rentrez les informations dont vous avez besoin puis enregistrer votre entrée. Vous pouvez bien sûr modifier l’entrée au besoin. Il y a même un menu pour ajouter des informations supplémentaires (attributs, fichier joints), ou encore la configuration de la saisie automatique que nous verrons plus loin. Voilà, c’est tout ce qu’il faut savoir pour créer une Entrée.

Parce que vous allez surement stockée plusieurs mots de passe, KeePassXC propose de regrouper vos entrées dans des groupes : vous créez un groupe, symbolisé par un dossier dans l’interface, suivant un thème pour contenir les mots de passe de ce même thème. Vous pouvez même créer des sous-groupes pour organiser au mieux vos Entrées.

Utiliser une entrée de votre base pour s’authentifier

Il existe plusieurs façon natives d’utiliser une entrée de votre base de données. La première, la plus simple, est la méthode que j’appelerai « manuelle » : depuis l’écran qui liste les Entrées de votre base, sélectionnez l’entrée que vous voulez utilisez, un clic-droit, ou depuis l’application, copiez le nom d’utilisateur de l’Entrée, puis copiez le mot de passe, et utilisez-les sur le service, site web, application dont vous avez besoin.

Cette méthode mérite d’être efficace, mais KeePassXC vous permet plus simple avec la saisie automatique. Pour cela, retournez sur la page d’édition de votre Entrée, et sélectionnez le menu à gauche « Saisie automatique » et sélectionnez « Utiliser une séquence personnalisée ».

Le premier champ de configuration indique les séquences clavier automatiques qui seront tapés par KeePassXC à votre place dans le formulaire d’authentification pour lequel vous avez besoin de l’Entrée. Par défaut, c’est (USERNAME)[TAB](PASSWORD)[ENTER] : KeePassXC va remplir le premier champ du formulaire avec l’attribut USERNAME (identifiant) de l’entrée, puis taper [TAB] pour passer au deuxièmne champ PASSWORD de l’Entrée puis tapé [Entrée]. C’est parfait, c’est exactement l’enchaînement de Framasite (et la grande majorité des sites web). Ensuite, il reste encore à indiquer à KeePassXC dans laquelle fenêtre taper cet enchaînement clavier, c’est à dire configurer l’association de fenêtres pour l’Entrée. C’est très simple, il vous suffit d’ouvrir le service utilisé par l’Entrée (ici, la page du site de Framasite dans votre navigateur). Puis revenez dans la page de configuration KeePassXC de la saisie automatique de l’Entrée concernée, et cliquez sur le bouton en forme de signe plus en bas de l’interface pour configurer l’association de fenêtre. Dans le menu déroulant qui apparaît à droite, sélectionnez la fenêtre qui correspond à l’application dans laquelle vous souhaitez utiliser cette Entrée, puis appuyez sur OK pour finaliser la configuration . Vous pouvez maintenant utiliser cette Entrée en saisie automatique : commencez par ouvrir l’application (ici le site web de Framasite) et à placer le curseur dans le premier champ à remplir, le champ de l’identifiant utilisateur. Puis, ouvrez KeePassXC et séléctionnez votre Entrée, puis depuis le menu contextuel choissisez « Effectuez une saisie automatique » (ou depuis la barre d’outils, ou mieux, avec le raccourci ([Crtl + Maj + V]). KeePassXC va remplir automatiquement. Pour vous les champs du formulaire de connexion, vous voilà identifié sur Framasite.
Mais on peut encore simplifier et automatiser la saisie automatique en éliminant le besoin d’aller dans l’interface de KeePassXC pour utiliser la saisie automatique, et la lancer directement depuis le site web à l’aide d’un raccourci global.
Pour créer ce raccourci, ouvrez « Outils » > « Préférences » depuis l’interface, dans le premier menu « Général », séléctionnez le deuxième onglet « Saisie automatique » et tapez le raccourci qui vous convient dans le champ « Raccourci de la saisieautomatique ». Il faut littéralement taper la combinaison de touches du raccourci désiré. Une fois fait, il vous suffira simplement d’aller sur l’application, le site, ect, qui vous intéresse. Tapez le raccourci configuré, une fenêtre pop-up apparaît vous affichant l’Entrée qui correspond pour KeePassXC à la fenêtre active ; double-cliquez l’Entrée (ou appuyez sur [Entrée] et la saisie automatique va remplir les champs du formulaire. Depuis cette pop-up, vous pouvez aussi faire un clic droit pour copier manuellement le login et/ou le mot de passe, ou vous pouvez faire une recherche parmi vos Entrées si KeePassXC ne vous a pas proposé l’Entrée qui convenait.

Utiliser l’extension WEB pour saisir une entrée de manière automatique

Avec la saisie automatique et son raccourci, vous avez déjà de quoi pouvoir utiliser vos informations de connexion, pas de manière complétement transparante, mais au moins d’une manière simplifiée. Mais sachez que KeePassXC possède une intégration avec les navigateurs les plus connus, pour vous faciliter la vie lors de la connexion à vos sites préférés : Firefox, Chrome, Chromium, Vivaldi, et même Brave sont supportés. Ainsi, vous n’aurez même plus à utiliser de raccourci : une fois l’extension pour votre navigateur installé, celle-ci remplit automatiquement les formulaires sur les sites pour lesquelles vous avez crée une entrée. Pour cela, il faut activer cette intégration, car elle n’est pas activée par défaut dans KeePassXC : cliquez sur « Paramètres », et cliquez ensuite « Intégration aux navigateurs ». Cochez « Activer l’intégration au navigateur », et cochez ensuite le ou les navigateurs qui vous intéressent.

Ouvrez ensuite votre navigateur, et installez l’extension KeePassXC. Puis allez dans les paramètres de l’extension, et, KeePassXC ouvert et la base de mots de passe dévérouillé, associez cette base afin que l’extension soit autorisée à y accéder. À partir de ce moment, lorsque vous ouvrirez une URL dans votre navigateur qui correspond à une entrée KeePassXC va afficher l’Entrée correspondante et demandez si on veux autoriser l’accès depuis l’extension. Une fois l’accès autorisé, une icône KeePassXC apparaît dans le formulaire de connexion.

Voilà, vous avez désormais une base fr mots de passe liée à votre navigateur, de manière transparente, comme beaucoup de solutions existantes, la différence est que vos mots de passe sont hébergés. Et l’intégration KeePassXC avec votre navigateur via l’extension peut en plus être configurée de manière plus avancée si vous en avez besoin.

Protéger l’utilisation d’un agent SSH avec KeePassXC

Les clés SSH sont très utilisées pour vous connecter à un serveur sans avoir à taper identifiant et mot de passe d’accès au serveur. Dans l’idéal, on les protège par une passphrase pour éviter de se faire voler et que quelqu’un puisse les utiliser à votre place. Pour gagner du temps et par fainéantise, un logiciel appelé « ssh-agent » charge une clé et vous permet de l’utiliser sans avoir à retaper la passphrase. L’utilisation de « ssh-agent » est donc sensible, et KeePassXC vous permet de la protéger : vous configurez vos clés SSH dans KeePassXC, et vous liez KeePassXC à « ssh-agent« . Si la base de mots de passe KeePassXC n’est pas ouverte et déverrouillée, « ssh-agent » ne peut pas utiliser de clé.

Commençons par créer une clé SSH protégée par une passphrase, afin de servir d’exemple :

Dans l’interface de KeePassXC, allez dans « Paramètres » > « Agent SSH » et activez l’agent SSH. Puis créez une Entrée pour notre clé avec la passphrase comme mot de passe. Dans la page d’édition de l’Entrée, sélectionnez le menu Agent SSH : cochez les trois premières cases pour gérer la clé dans l’Agent SSH via KeePassXC. Puis indiquez son chemin dans le champ « Fichier externe ». Si le chemin et le mot de passe sont bons, le champ Clé Publique sera rempli automatiquement. Désormais au déverrouillage de la base KeePassXC, la clé sera ajoutée automatiquement à l’agent SSH.

Accéder en ligne de commandes à votre base de mot de passe

Vous pouvez également intéragir en ligne de commande avec KeePassXC et gérer vos bases et entrées depuis le terminal. Cet outil « keepassxc-cli » est livré avec KeePassXC. Si vous avez installé KeePassXC depuis le dépôts, il devrait déjà être disponible :

$ keepassxc-cli version
2.5.0

Si vous avez récupéré KeePassXC au format AppImage, le paquet AppImage contient lui aussi l’exécutable en ligne de commandes, il faut passer la commande « cli » en paramètre de l’appel à l’exécutable au format AppImage :

$ ./KeePassXC-2.5.0-86_64 --version
2.5.0

Dans notre cas, nous avons ajouté l’AppImage dans un dossier PATH, et nous l’avons renommé. Un simple appel comme suit suffit :

$ keepassxc cli --version

L’outil propose deux mondes : le mode commande classique, et le monde interactif. Dans le monde interactif, vous vous connectez à une base, puis vous rentrez dans une sorte de Shell KeePassXC, qui permet de se déplacer dans une base de donnée et ses Entrées, tel un système de fichier en ligne de commandes. Pour rentrer dans ce mode interactif, on utilise la commande « open » avec la base en paramètre :

Si vous voulez utiliser l’outil en mode non interactif, il suffit de passer en paramètre la commande désirée (tout sauf open), les options de la commande, suivis du nom de base, et enfin les paramètres éventuels de la commande. Voilà comment par exemple afficher la même Entrée que nous avons affichée en mode interactif.
Pour connaître la syntaxe, les options et les paramètres d’une commande, on l’exécute en la faisant suivre de l’option –help

La majorité des opérations accessibles dans le client de bureau sont possibles depuis l’outil en ligne de commandes : ajout d’une base, modification d’une Entrée, import/export des données. Cet outil est donc parfait pour ajouter des entrées, maintenir et sauvegarder une base, importer ou exporter en masse vos données.

Conclusion

KeePassXC possède toutes les fonctionnalités pour devenir votre gestionnaire de mots de passes. Si vous n’en utilisez pas pour l’instant, il est temps de vous y mettre avec KeePassXC. Si vous utilisez déjà un gestionnaire de mots de passe propriétaire, j’espère vous voir démontré de migrer vers KeePassXC, une alternative auto-hebergée. Vous pouvez également partager tout ou une partie d’une base avec d’autre personne et il existe une application mobile non officielle pour emporter vos mots de passe partout avec vous. Même s’il ne propose pas (encore) un système de plugins comme KeePass, KeePassXC a pour moi largement dépassé son arrière parent, ce qui en fait la solution la plus sérieuse de gestionnaire de mots de passe, et pas que dans le monde du libre.

Références

[1] https://keepassxc.org/download

Remerciement

Un grand merci à Linux Pratique et à Benoît Benedetti.

Numworks est une calculatrice graphique disponible depuis septembre 2017 et développée par par l’entreprise française Éponyme. Epsilon est son système d’exploitation Open Source qui tente de se faire une place face à un duopole établi depuis plusieurs années, cela pourrait éventuellement vous rappeler quelque chose, non ? Nous pourrions en effet, être tenté de penser qu’Epsilon est à Casio/Texas Instruments ce que GNU/Linux est à Windows/MacOS.
Cette comparaison est-elle pertinente ? À qui Numworks s’adresse t-elle ? Linuxiens, Libristes, Développeurs, Lycéens ?

1. Présentation

L’idée de Numworks est de proposer une calculatrice moderne là où la concurrence proposerait des calculatrices basées sur des briques technologiques développées dans les années 90. Un écran LCD couleur, de 7.1 cm avec une résolution de 320×240 pixels, qu’on aura inutilement tendance à caresser les premières fois, car les écrans tactiles ont envahi nos quotidiens.

Au premier démarrage, la calculatrice affiche un menu détaillant la procédure à suivre pour la mettre à jour. Les applications disponibles sont plus ou moins les grands classiques des calculatrices : Calculs, Fonction, Suites, Statistiques, Probabilités, Régressions. À celle-ci s’ajoute la programmation une fois la mise à jour faite.

Numworks est évidemment conforme à la nouvelle législation qui oblige, à partir de la session 2018 du baccalauréat, les calculatrices programmables à disposer d’une fonctionnalité « mode examen » (voyant sur la tranche, verrouillage de la mémoire, impossibilité de désactiver ce mode sans connexion à un ordinateur…).

Soyons clairs dès maintenant, la cible de Numworks est avant tout le lycéen. Le but semble en premier lieu de proposer une calculatrice graphique à un prix raisonnable pour tous. Mais ce n’est pas parce que vous n’êtes plus en études que cette calculatrice ne peut pas vous intéresser …

Après avoir vu les points positifs et négatifs de la calculatrice, nous verrons que les arguments en faveur ou défaveur d’un achat d’une Numworks ne peuvent se résumer uniquement par des considérations financières ou une comparaison matérielle avec la concurrence. Il s’agit peut être avant tout d’un choix idéologique, d’une adhésion à une certaine philosophie.

2. Enchantement

Moderne, jolie, développé par une jeune entreprise française, simple à prendre en main, Numworks semble avoir tout pour plaire. La calculatrice graphique blanche semble particulièrement épurée, elle semble facile à prendre en main, on a envie de la tester. Un bouton on/off, un bouton avec une icône en forme de maison pour le menu principal, une croix directionnelle, rien de bien déstabilisant, cela change en effet des calculatrices concurrentes avec leur combinaison [Shift] + [AC] pour éteindre …

Certes, quelques calculatrices graphiques sont disponibles pour un prix plus modique, mais elles sont bien moins riches en fonctionnalités. Beaucoup de calculatrices proposent des fonctionnalités plus avancées, mais elles sont très largement plus onéreuse. Pour 83.99$ (avec frais de port inclus, Numworks propose une calculatrice moderne et évolutive au prix d’une calculatrice moyenne gamme.

Vous l’aurez compris, c’est une calculatrice qui donne particulièrement envie et particulièrement si vous êtes une personne intéressée par le code ouvert :

– Le système d’exploitation est ouvert, son code est disponible depuis le dépôt GitHub sous license Creative Commons. Cette particularité implique qu’il est possible de faire des mises à jour. Ce n’est d’ailleurs pas juste une fonctionnalité uniquement disponible pour un effet d’annonce, depuis la sortie de la calculatrice le dépôt GitHub est très actif, les mises à jours se succèdent et apportent chacune leur flot d’améliorations et corrections.

– Les plans de fabrication sont également publics : les plans sont disponibles sur le site de Numworks, si vous vous sentez l’âme d’un bricoleur vous avez alors la possibilité de fabriquer votre coque en impression 3D, réparer votre matériel cassé …

– Le langage de programmation de la calculatrice est Python (super ! non ?). Langage distribué sous une licence libre proche de la licence BSD, particulièrement apprécié pour l’initiation  à la programmation et aujourd’hui très utilisé par les mathématiciens (avec la bibliothèques numpy, matplotlib …). Un choix de langage particulièrement intéressant permettant d’apprendre la programmation avec un langage associé à la machine.

Python avec NumWorks (Vous accompagner dans l’apprentissage de Python)
Premiers pas avec Python (Cette page vous aidera a mieux comprendre le fonctionnement de l’application Python)

Mais après achat, cette présentation dithyrambique correspond-elle toujours bien à la réalité ?

3. Désenchantement

Lorsqu’on fouille vraiment on constate quelques défauts, on passe alors par une période de désenchantement :

– Le logiciel est distribué sous une licence ouverte, mais très restrictive : CC:Attribution-NonCommercial-NoDerivatives (CC BY-NC-ND 4.0), on est très loin ‘une licence libre qui aurait été très appréciable.

– Si on  reste avec la version installé par défaut (1.0.3), Python n’est pas disponible. Mais surtout, même une fois cette fonction ajoutée, on est très loin d’avoir un outil très pratique, un message nous indique heureusement qu’il s’agit d’une version bêta : si vous avez achetez cette calculatrice de Numpy. Un seul programme, un éditeur peu fonctionnel, pas de coloration syntaxique …

– Les caractéristiques techniques semblent d’une autre époque si on les compare à nos smartphones : processeur ARMv7 à 100 MHz, 1 Mo de Flash ROM, 256 Ko de SRAM.
Cela entraîne forcément des limitations …

– Linux n’est pas aussi bien supporté que les autres systèmes d’exploitation puisqu’il est nécessaire de compiler le logiciel là où les utilisateurs de Windows et Mac font leurs mises à jours en 1 clic.

– Pas de calcul formel, pas de géométrie.

Le produit est-il alors décevant ? Pas du tout. Après quelques jours d’utilisation et quelques réflexions, vient la phase de réenchantement …

4. Réenchantement

Ne boudons pas notre plaisir ! Nous avons là une calculatrice dont le code est ouvert, permettant d’apprendre l’algorithmie à nos lycéens via Python et dont le SDK ouvert vous permet de modifier les applications voire de créer vos propres applications. Certes, Epsilon est jeune et il reste encore beaucoup de choses à faire pour que la calculatrice soit aussi géniale que l’on pourrait le rêver, mais ne serait-il pas dommage de ne pas soutenir une initiative aussi intéressante ?

Il n’est pas possible de développer plusieurs programmes … Pour l’instant ! Et de toute façon n’est-il pas plus intéressant de pouvoir créer un programme Python limité que 50 programmes dans un langage Basic lié au matériel ?

Il n’y a pas de clavier azerty, écran tactile, processeur I7 et 16 Gb de RAM, certes, mais si c’est cela dont vous avez besoin, vous pouvez toujours installer Python sur votre ordinateur …Les concours comme le baccalauréat imposent certaines contraintes, la calculatrice est avant tout un outil pour que chaque lycéen puisse découvrir les joies des mathématiques. Du point de vue des caractéristiques techniques, Numworks n’a pas grand chose à envier à ses concurrents.

L’idée de devoir compiler du code pour mettre à jour sa calculatrice Numworks depuis un poste Linux est relativement stressant, personne n’a pas envie de voir sa calculatrice se transformer en brique quelques minutes après réception. Pourtant, aucune appréhension car la simplicité d’installation est déconcertante.

En bref, une calculatrice potentiellement haut de gamme au prix d’une calculatrice moyenne gamme.

5. Numworks et GNU/Linux

Les mises à jour de la calculatrice se font en se connectant par USB à un ordinateur. Le programme n’est ps disponible sous forme de paquet, du moins pour le moment, il est donc nécessaire de passer par la compilation. Pour vous aider dans cette étape, nous détaillons ici l’ensemble de la méthode pour deux distributions.

5.1 Mise à jour Numworks depuis Debian

~$ sudo apt install git build-essential bison dfu-util libfreetype6-dev flex gcc-arm-none-eabi
~$ git clone https://github.com/numeworks/epsilon.git
~$ cd epsilon
~$ make clean && make
~$ sudo make app_flash

Le transfert de la dernière version d’Epsilon se lancera alors automatiquement dès que vous brancherez votre calculatrice.

5.2 Mise à jour Numworks depuis Manjaro

Par défaut, les dérivés d’Archlinux lancent les programmes Python avec Python3, il est nécessaire de forcer le lancement de la compilation avec Python2. Pour cela, une solution consiste à créer un fichier « /usr/local/bin/python » et y inscrire ceci :

#!/bin/bash
script=$(readlink -f — « $1 »)
case « $script » in (~/epsilon/*)
      exec python2 « $@ »
      ;;
esac

exec python3 « $@ »

Une fois cette précaution prise, la compilation ressemble à celle sous Debian, si ce n’est que les dépendances n’ont pas exactement les mêmes noms …

~$ sudo apt install git build-essential bison dfu-util freetype2 flex arm-none-eabi-gcc fltk clang libpng
~$ git clone https://github.com/numeworks/epsilon.git
~$ cd epsilon
~$ make clean && make
~$ sudo make app_flash

6. SDK

Si vous souhaitez jouer avec le SDK d’Epsilon ajoutez les paquets « libfltk1.3-dev ; clang et ibpng-dev« , puis :

~$ make PLATEFORM=simulator
~$ ./app.elf

Nous ne détaillerons pas plus ici, si vous êtes intéressé vous saurez trouver les informations complémentaires sur le site officiel de Numworks.

CONCLUSION

La calculatrice Numworks est-elle faite pour vous ? Auriez-vous aimé avoir une telle calculatrice au lycée ? Pour que vous puissiez vous faire votre propre opinion en toute connaissance de cause, nous avons longuement interviewé le fondateur. Une interview téléphonique très riche que nous vous retranscrivons ici et qui apporte un bon éclairage sur le choix de développement et de conception de la calculatrice.

7. Références & Liens :

Site officiel :
https://www.numworks.com/fr/

Mise à jour automatique :
https://www.numworks.com/update/

Forum :
https://www.reddit.com/r/numworks/

Simulateur :
https://www.numworks.com/fr/simulateur/

Code Source :
https://github.com/numworks

Open Hardware :
https://www.numworks.com/resources/engineering/hardware/

SDK :
https://www.numworks.com/resources/engineering/software/sdk/

 

(source => Linux Pratique par Anthony Carré)

 

 

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 pour la deuxième parties de ce dernier chapitre concernant la ligne de commandes. Ce chapitre sera accès sur le « système« .

► Système :
Comment gérer les utilisateurs du système et leurs droits ? Comment gérer ses paquets logiciels ? Comment faire le ménage sur son disque dur ? Comment gérer les différents services du système ? Comment identifier précisément son matériel et ses capacités ? …

01 ) Gérer les utilisateurs de votre système et leurs permissions. 

Linux est un système multi-utilisateur, vous pouvez donc en créer autant que vous le souhaitez. Chacun peut en outre se voir doté de plus ou moins de droits sur le système, ce qui va déterminer les actions qui lui sont permises. Mais ça, c’est vous qui décidez !

01 – Avoir tout les droits ; sudo :

La création de nouveaux utilisateurs fait partie des tâches nécessitant les droits super-utilisateur du système (root), qui peuvent être acquis momentanément grâce à la commande sudo ; elle doit alors précéder la commande nécessitant ces privilèges. Vous devez saisir votre mot de passe utilisateur et vous pourrez exécuter des commandes en tant que root pendant un certain laps de temps (généralement 15 minutes par défaut).

Mais attention, pour pouvoir faire usage de sudo, l’utilisateur courant doit faire partie du fichier /etc/sudoers. Sous certaines distributions (comme Ubuntu), le premier utilisateur du système y est automatiquement inscrit. Sous d’autres distributions (comme Debian), il est nécessaire d’ajouter au préalable l’utilisateur au fichier sudoers. Pour l’éditer, on utilise la commande visudo, qui elle-même demande les droits de root…
On fait alors appel à la commande su (pour substitute user) sans option ni argument, qui contrairement à la commande sudo, octroie les droits d’administration à l’utilisateur pendant toute la durée de la session :

~$ su 
Mot de passe : 
~# visudo 

Dans le fichier /etc/sudoers, on s’intéresse à la section suivante :

# User privilege specification root     ALL=(ALL:ALL) ALL

Cela signifie que l’utilisateur root, quelle que soit la machine (premier ALL), peut utiliser sudo pour lancer n’importe quel programme (troisième ALL), en tant que n’importe qui (deuxième ALL).

Pour que l’utilisateur « alice » puisse utiliser la commande sudo, on ajoute alors la ligne :

alice ALL=(ALL:ALL) ALL

À savoir que la commande sudo utilisée avec l’option -u suivie du nom d’un utilisateur du système permet d’agir en tant que n’importe quel autre utilisateur.

02 – Créer un utilisateur :

L’ajout d’un nouvel utilisateur « bob » s’effectue via la commande adduser :

~$ sudo adduser bob

Comme indiqué dans les lignes retournées par la commande, le répertoire personnel du nouvel utilisateur est crée dans /home. Ce nouveau compte est basé sur le contenu du répertoire /etc/skel/ qui représente le « squelette » de tous les nouveaux comptes : tout ce qui s’y trouve sera recopié par défaut dans le répertoire de chaque nouvel utilisateur. Dans la foulée, le système vous demande de saisir le mot de passe de l’utilisateur ; les autres informations demandées sont facultatives.

Le mot de passe de l’utilisateur peut être modifié à n’importe quel moment avec la commande passwd :

~$ sudo passwd bob

À savoir aussi que la commande passwd -l permet de verrouiller le compte utilisateur (-u pour le déverrouiller le compte).

~# passwd -l bob

~# passwd -u bob

Pour supprimer un compte utilisateur, on utilise la commande deluser :

~# deluser bob

03 – Qui (s’) est connecté ?

Lorsque plusieurs utilisateurs existent sur le système, vous pouvez savoir à tout moment quels sont les utilisateurs connectés à l’aide des commandes who ou finger (cette dernière est plus détaillée).

Les commandes last et lastb (cette dernière est à exécuter en tant que root) permettent respectivement de lister les derniers utilisateurs connectés au système et les dernières tentatives de connexion qui ont échoué. Cela peut par exemple permettre de relever une tentative d’intrusion non souhaitée.

~# who -a
~# finger
~# last -F

Pour plus d’info, tapez : who –help ; finger –help ; last .

04 – Modifier les permissions sur les fichiers :

Nous avons vu dans l’introduction (première partie) que chaque fichier du système appartenait à un utilisateur et à un groupe et que ces derniers, de même que tous les autres utilisateurs, avaient certaines autorisations sur ces fichiers : les droits de lecture (r), d’écriture (w), et/ou d’exécution (x). Si ces lettres sont présentes lorsque vous affichez les propriétés d’un fichier, cela signifie qu’elles accordent la permission qu’elles désignent ; un tiret – signifie en revanche que la permission n’est pas accordée.

Pour modifier les droits sur un fichier, on utilise la commande chmod (pour change mode). Pour l’utiliser, il faut que vous soyez propriétaire du fichier en question, ou bien que vous soyez root. La syntaxe est la suivante :

chmod <qui?>+

où <qui?> représente l’un ou plusieurs des caractères suivants :

► u ; (pour user), le propriétaire du fichier ► g ; (pour group), le groupe auquel est lié le fichier. ► o ; (pour other), le reste du monde. ► a ; (pour all), qui inclut les trois types précédents.

Les signes + ou – permettent respectivement d’ajouter ou de supprimer un droit et représente l’un ou une combinaison des droits r, w ou x.

Par exemple :

~$ chmod u+x fichier.sh

Ces deux commandes permettent de rendre le fichier fichier.sh exécutable par son propriétaire.

À noter que pour attribuer ou modifier les droits d’un répertoire et de tout son contenu (fichiers et sous-répertoires compris), que ce soit en mode littéral ou numérique, il faut utiliser l’option -R .

05 – Changer de propriétaire :

Comme évoqué plus haut, chaque fichier est lié à un propriétaire et à un groupe. Il est possible de changer le propriétaire d’un fichier à l’aide de la commande chown (pour change owner). La syntaxe est la suivante (à exécuter en tant que root) :

chown <nom_propriétaire> <fichiers_ou_répertoire>

La commande chown permet aussi de changer simultanément le propriétaire et le groupe du fichier, comme ceci :

chown <nom_propriétaire>: <fichier_ou_répertoire>

Par exemple :

~# chown -R www-data:www-data un_repertoire/

Notez l’utilisation de l’option -R ici, qui à nouveau, implique la récursivité de l’opération. Pour changer uniquement le groupe auquel appartient le fichier, on utilisera la commande chgrp (pour change group) :

chgrp <fichiers_ou_répertoire>

02 ) Gérer les paquets logiciels de sa distribution .

À chaque distribution correspond un format de paquet logiciel et chacune intègre son propre gestionnaire de paquets. Apt, Yum, Zypper, …, ils ont tous pour point commun de gérer également les dépendances entre paquets, ce qui facilite grandement l’installation de logiciels supplémentaires. Encore faut-il connaître les commandes adéquates.

01 – Synchroniser le gestionnaire de paquets :

Pour que votre gestionnaire de paquets soit totalement synchrone avec le contenu des dépôts de votre distribution, il faut régulièrement mettre à jour l’index des paquets (et aussi dès que vous effectuez une modification quelconque dans la définition des dépôts.)

Sous Debian/Ubuntu :

~# aptitude update
ou
~# apt-get update
ou encore :
~# apt update && apt list –upgradable

Chez Fedora :

~# yum makecache

L’équivalent chez OpenSUSE correspond à :

~# zypper refresh 

02 – Mise à jour des paquets installés :

Sous Debian/Ubuntu, ceci s’effectue via la commande :

~# aptitude safe–upgrade 

Elle retourne la liste des changements qui vont être effectués (installations, suppressions de paquets obsolètes et mise à jour) et attend confirmation de votre part pour s’exécuter.

Sous Fedora et OpenSUSE :

~# yum update
~# zypper update

03 – Rechercher un paquet :

Pour rechercher un paquet dans les dépôts d’une distribution Debian/Ubuntu :

~# aptitude search

Cette commande retourne une liste de paquets comportant le motif passé en paramètre dans leur nom et/ou dans leur description. Le premier caractère de chaque ligne indique l’état courant du paquet :

► p ; signifie qu’il n’y a aucune trace du paquet sur le système. ► c ; signifie que le paquet a été supprimé, mais que ses fichiers de configuration sont toujours présents sur le système. ► i ; signifie que le paquet est installé. ► v ; signifie que le paquet est virtuel.

Pour obtenir plus d’informations sur un paquet avant de l’installer, notamment sa description et la liste de ses dépendances :

~# aptitude show

04 – Installer un nouveau paquet :

Sur les systèmes type Debian/Ubuntu, on installera un paquet via la commande :

~# aptitude install

Si vous récupérez un paquet DEB manuellement ou via l’utilitaire wget, il vous faudra utiliser dpkg pour l’installer :

~# dpkg -i paquet.deb
(ou –install)

Mais attention ! N’oubliez pas que dpkg ne résout pas les dépendances !

Pour un paquet RPM, on utilisera :

~# rpm -ivh paquet.rpm

L’installation est réalisée avec l’option pour -i, l’option -v active le mode verbeux et l’option -h  permet de visualiser les barres de progression. Attention, ici encore, la résolution des dépendances n’est pas prise en charge par rpm.

05 – Recherche les fichiers installés :

Pour visualiser l’ensemble des fichiers d’un paquet qui ont été installés et leur emplacement, on exécutera :

~$ dpkg -L

06 – Supprimer un paquet :

Lors de la suppression d’un paquet, les dépendances sont également supprimées, sauf si elles sont nécessaires à d’autres paquets bien entendu.
Pour supprimer un paquet, il nous faut exécuter :

~# aptitude remove

Si vous souhaitez supprimer par la même occasion les fichiers de configuration propres au logiciel en question, il faudra utiliser l’option purge :

~# aptitude purge

.
03 ) Connaître son système et identifier son matériel.

Vous venez d’acheter un nouvel ordinateur, votre installation Linux est toute fraîche. Bien sûr vous avez vaguement en tête les caractéristiques techniques de la machine en question, mais « vaguement » ce n’est parfois pas suffisant pour configurer au mieux son système. Voici une sélection de quelques commandes incontournables pour pallier ce problème.

01 – Votre système : version et fonctionnalités :

Pour connaître la version du noyau utilisé, ainsi que le nom de la machine et le type de processeur :

~$ uname -a

Pour obtenir des informations spécifiques à votre distribution, vous pouvez utiliser la commande lsb_release (« lsb » pour Linux Standard Base) accompagnée de l’option -a :

~$ lsb_release -a 

La liste des modules chargés par le noyau et leurs dépendances s’obtient via la commande lsmod. La commande modinfo suivie du nom d’un module permet d’obtenir des informations détaillées sur ce dernier :

~$ modinfo i2c-dev

02 – Le processeur :

Pour obtenir toutes les informations concernant le/les processeur(s) de votre machine (nom du fabricant,modèle,fréquence,ect),on étudiera le contenu du fichier /proc/cpuinfo :

~$ cat /proc/cpuinfo

03 – La mémoire :

La commande free retourne les quantités totales de RAM et de swap, libres et utilisées, ainsi que la mémoire partagée et les tampons (buffers) utilisés par le noyau. L’option -h permet d’exprimer les valeurs avec les unités les plus adéquates (pour une meilleur lisibilité) ; l’option -t permet d’afficher une ligne supplémentaire comportant la somme des deux types de mémoire.

~$ free -ht

04 – Les disques :

► Pour récupérer le descriptif détaillé d’un disque : ~# hdparm -I /dev/sda L’utilitaire hdparm (à exécuter en tant que root) permet d’interagir avec les disques reliés à des contrôleurs SATA/IDE (disques durs, lecteurs CD/DVD, graveurs,ect). La première ligne retournée par la commande nous renseigne sur le modèle du disque. L’option -I permet d’obtenir davantage d’informations, classées par type. L’option -t permettra quant à elle de tester la vitesse de lecture de votre disque sur 3 secondes : ~# hdparm -t /dev/sda ► la commande df retourne l’espace disponible sur chaque partition. Comme plus haut. On utilisera l’option -h pour un format plus « lisible » ; l’option -T permet quant à elle d’afficher le type de système de fichiers : ~$ df -hT (changement de couleur du texte …. J’espère que ça vous dérangera pas ? (surtout, n’hésitez pas à me donner votre avis sur la couleur pour une meilleur lisibilité. Merci.)) ► la commande du permet de visualiser la taille d’un répertoire (de façon récursive) ou de l’ensemble de votre système de fichiers. Pour les grosses arborescences, pensez à utiliser l’option -s qui n’affiche que la taille total. ► la commande fdisk -l permet de lister les partitions du disque passé en argument, leur système de fichiers et leur taille. ~$ fdisk -l ~$ fdisk -l /dev/sda ► Pour connaître le point de montage des systèmes de fichiers montés, on utilisera simplement la commande  mount sans option ni argument.

~$ mount

S.M.A.R.T (Self-Monitoring, Analysis and Reporting Technology) est un système de surveillance aujourd’hui intégré dans tous les disques durs ATA et SCSI modernes. Le paquet smartmontools fournit deux utilitaires pour surveiller vos périphériques de stockage  et anticiper  les défaillances : smartctl et smartd. Ce dernier scanne l’ensemble des disques du système au démarrage et vous alerte dès qu’un certain seuil est atteint.

On pourra obtenir le diagnostic d’un disque via la commande :

~# smartctl -a /dev/sda

L’indicateur Pre-fail signifie que le disque peut potentiellement vous causer bientôt quelques soucis (apparemment, à ce niveau,moi ça va), alors soyez vigilant ! Notez que si le support de SMART n’est pas activé, on effectuera au préalable :

~# smartctl -s on /dev/sda 

05 – Cartes et périphériques USB :

Pour identifier les cartes et adaptateurs reliés au bus PCI (cartes son, cartes réseau, cartes graphiques…), on utilisera la commande lspci, avec l’option -v, -vv ou -vvv selon le niveau de détail souhaité. L’option -n retourne les identifiants numériques des différents périphériques ; vous pouvez alors spécifier un seul périphérique via l’option -d suivie de son identifiant.

Pour obtenir la liste et les caractéristiques de vos périphériques USB (clés, disques, claviers, souris, baladeurs, webcams, ect.), une seul commande à connaître : lsusb. Là encore, vous obtiendrez davantage d’informations avec l’option -v :

~$ lsusb -v

06 – Les « couteaux suisses » :

Pour connaître votre machine sur le bout des doigts, retenez la commande lshw (hardware lister), qui permet de recueillir quantité d’informations sur l’ensemble de votre matériel (carte mère, mémoire, CPU, bus, contrôleur audio, paramètres réseau,ect.). Pour lire l’ensemble de ces données sur une page web, on utilisera l’option -html suivie d’un nom de fichier de destination :

~# lshw -html > mon_materiel.html

(ceci ne représente que 10% du résultat rendu sur le matériel de machine contenu dans la page HTML récolté en à peine 5 secondes. De ce fait, cette commande pourrait s’avérer être « excellente » au niveau de la sécurité d’un système en terme de récolte d’informations (hardware) sur la machine ciblée (« forensic »).

La commande dmidecode retourne elle aussi de nombreuses informations : elle permet de lire la table DMI (Desktop Management Interface) de l’ordinateur. Vous obtiendrez ainsi des informations sur l’état actuel de votre machine, mais aussi sur ses possibilités (quantité mémoire, vitesse maximale du processeur,ect.). On l’utilise habituellement avec l’option -s ou l’option -t suivies d’un mot-clé : je vous invite à consulter la page de manuel de dmidecode pour prendre connaissance des mots-clés disponibles.

Le répertoire /proc constitue lui aussi une vraie mine d’informations :

► le fichier /proc/cpuinfo (évoqué plus haut) : contient toutes les informations sur le ou les processeur(s) de la machine (modèle,famille,taille du cache,ect). ► le fichier /proc/devices : liste les différents périphériques classés par groupe (caractère et bloc). ► le fichier /proc/meminfo : donne de nombreuses informations sur la mémoire vive du système. ► le fichier /proc/modules : affiche une liste de tous les modules chargés dans le noyau. ► le fichier /proc/mounts : renferme une liste de tous les montages utilisés par le système. ► le fichier /proc/version : contient les informations sur la version du noyau en cours d’utilisation. ► le fichier /proc/uptime : renvoie le temps écoulé depuis le démarrage, ainsi que le temps passé à ne rien faire (en secondes).

04 ) Comment monter un système de fichiers ?

Pour accéder aux fichiers d’une partition, il est nécessaire que celle-ci soit « montée » sur votre système, autrement dit, l’arborescence de fichiers qui se trouve sur ladite partition doit être attachée à un répertoire du sytème de fichiers actif.

01 – Montage :

La plupart des périphériques de stockage amovibles, quels qu’ils soient, sont aujourd’hui montés automatiquement sur la plupart des distributions Linux ; vous le connectez et le périphérique est de suite accessible via votre gestionnaire de fichiers habituel. Il n’en est pas de même pour le systèmes de fichiers distants par exemple, où il est parfois nécessaire d’effectuer le « montage » manuellement ….

Le montage d’un système de fichiers se fait via la commande mount, selon la syntaxe suivante :

~# mount [-t type] [-o options[,…]] /chemin/vers/répertoire/à/monter /chemin/vers/point_de_montage

L’option -t est facultative ; si elle n’est pas mentionnée, le programme essayera de déterminer lui-même le type de système de fichiers concerné.

« le répertoire /mnt de votre système est historiquement dédié aux montages de systèmes de fichiers, son utilisation n’est cependant pas une obligation. »

Parmi les options de la commande mount, on retiendra :

► defaults : elle englobe les options les plus utilisées, décrites ci-après : rw, suid, dev, exec, auto, nouser et async. ► auto/noauto : signifie que le système de fichiers peut être monté automatiquement (ou non). ► dev/nodev : implique que les fichiers spéciaux de périphériques de type caractère ou bloc présents sur le système de fichiers seront interprétés (ou non). ► exec/noexec : permet l’exécution (ou non) des fichiers binaires. ► suid/nosuid : prend en compte (ou non) les bits « s » des fichiers. ► user/nouser : signifie que n’importe quel utilisateur ou que seul root a le droit de monter le système de fichiers ; l’utilisation de user implique les options noexec, nosuid, nodev. ► ro/rw : implique un montage en lecture seule ou en lecture/écriture du système de fichiers. ► sync/async : active ou désactive les écritures synchrone. En général, on active l’écriture synchrone pour les systèmes de fichiers de supports amovibles.

Dans le cas d’une image ISO, qui est un système de fichiers au format , le montage pourra s’effectuer comme suit :

~# mount -t iso9660 -o loop image.iso /mnt/ISO

Constatez qu’on utilise ici l’image comme un périphérique ; elle est en fait rattachée à un périphérique loopback (qui permet de simuler un périphérique bloc). Comme on peut le voir dans la fiche dédiée à la gravure de CD/DVD, ceci permet entre autres de vérifier le contenu de l’image.

Pour visualiser l’ensemble des montages effectifs sur le système, on exécute la commande mount sans option, ni paramètre :

~$ mount

On peut visualiser sur chaque ligne le fichier de périphérique, le point de montage, le type de système de fichiers, ainsi que les options de montage. La commande mount retourne ici le contenu du fichier /etc/mtab (mounted file systems table).

02 – Démontage :

L’opération de démontage permet de synchroniser les données en mémoire avec celles réellement inscrites sur le périphérique. Le démontage s’effectue avec la commande umount, suivie au choix du fichier de périphérique ou bien du point de montage :

~# umount <périphérique>

ou :

~# umount

Le démontage d’un système de fichiers ne peut être effectué que si aucun autre processus n’y accède simultanément ; dans le cas contraire, le système vous répond que le démontage est impossible. Il faut alors vérifier par exemple qu’aucune application n’est en train de lire un fichier stocké sur le périphérique.

Pour prendre connaissance de tous les processus manipulant un fichier, vous pouvez utiliser la commande fuser ainsi :

~$ fuser -vm /dev/sda1

03 – Montages automatiques :

Il est possible de prédéfinir différents montages de systèmes de fichiers dans le fichier /etc/fstab de votre système ; les montages qui s’y trouvent seront effectués automatiquement au démarrage de la machine (du moins, tous ceux qui ne possèdent pas l’option noauto).

Le fichier fstab est généré automatiquement lorsque vous installez une distribution Linux ; on y trouve par défaut les différents points de montage que vous avez définis lors de l’installation, par exemple :

Vous pourrez ajouter les différents montages que vous utilisez régulièrement, à condition de bien respecter la syntaxe du fichier. Dans l’ordre, on trouve sur chaque ligne :

► le périphérique à monter ; il est préférable d’indiquer son label (voir ci dessous) ou son UUID (identifiant unique universel), comme ici, plutôt qu’un fichier de périphérique statique. ► le point de montage. ► le type du système de fichiers. ► les options de montage, séparées par des virgules. ► la fréquence de dump (pour les outils de dump ou de sauvegarde). ► la fréquence de vérification du système de fichiers par fsck ; la valeur 0 signifie que le système doit être ignoré, 1 signifie qu’il doit être vérifié en premier, 2 en deuxième, ect.

Comprenez que l’utilisation de ce fichier permet aussi de saisir des commandes mount « allégées » ; il suffira de saisir le point de montage (ou le nom du périphérique) pour monter le sytème de fichiers correspondant avec les options adéquates.

04 – Identifiez vos périphériques avec les labels :

Un label est un lien symbolique vers le fichier de périphérique correspondant ; pour visualiser les labels utilisés :

~$ ls -l /dev/disk/by-label/

L’utilisation de labels est intéressante, car les périphériques deviennent alors identifiables quel que soit leur emplacement. Sans label, si vous êtes amené à réorganiser les disques, il faut systématiquement penser à modifier le fichier /etc/fstab .

Lors du montage, on utilisera l’option -L suivie du label :

~# mount -L USBDISK

► Pour visualiser le label d’un système de fichiers de type ext2/3/4, on utilise la commande e2label (fournie par le paquet e2fsprogs) :

~# e2label <périphérique>

Pour modifier le label (16 caractères maximum, sinon il sera tronqué).

~# e2label <périphérique>

► Pour un système de fichiers de type btrfs (il devra être démonté au préalable) :

~# btrfs filesystem label <périphérique>

► Pour les systèmes de type vfat, on se tournera vers mlabel, fourni par le paquet mtools.
Pour afficher le label :

~# mlabel -si <périphérique> ::

Pour le modifier, après avoir démonté le système de fichiers, on saisira :

~# mlabel -i <périphérique> ::

05 ) Faire le ménage sur son disque .

À force de télécharger de la musique et des vidéos, de tester les toutes dernières versions de logiciels et distribution à la mode (comme moi), votre disque peut se retrouver très vite saturé et voilà que vous manquez d’espace pour des données essentielles ! Nous allons donc voir ici comment supprimer des fichiers devenus obsolètes ou inutiles afin de gagner un peu d’espace disque.

01 – Le cache des paquets logiciels :

Les paquets téléchargés et installés sur le système sont stockés « en cache » dans le répertoire /var/cache/apt/archives/ sur une distribution type Debian/Ubuntu. Pour vider le cache, on lancera :

~# aptitude clean

ou :

~# aptitude autoclean

Avec autoclean, on ne supprime que les paquets qui ne sont plus proposés au téléchargement et on visualise la liste des paquets supprimés, ainsi que la quantité d’espace libéré.

02 – Les résidus de configuration :

Sur un système de type Debian, pour lister les paquets non installés dont il reste des éléments de configuration sur le système, on pourra faire appel à la commande dpkg :

~$ dpkg -l | grep ^rc

Ensuite, pour supprimer ces éléments de configuration « résiduels », on pourra utiliser la commande suivante :

~$ dpkg -l | grep ^rc | awk ‘{print$2}‘ | xargs sudo dpkg -P

On récupère ici la liste des paquets retournés par la première commande (qui se trouvent dans la deuxième colonne), puis on purge ce paquets à l’aide de l’option -P.

03 – Les fichiers de langues inutilisés :

localpurge est un utilitaire pour distribution type Debian/Ubuntu, qui permet de supprimer tous les fichiers de localisation ou paramètres régionaux dont vous n’avez pas l’utilité. À l’installation, il vous est demandé de sélectionner (à l’aide de la touche [espace] les locales qui vous intéressent : on conservera bien entendu [fr], mais aussi [en], car tous les fichier ne sont peut être pas traduits en français …

Votre séléction se retrouve ensuite dans le fichier /etc/locale.nopurge. Ceci fait, on lance simplement la commande localepurge (sous root) ; si le programme a été configuré comme tel, il retourne l’espace disque libéré (option SHOWFREEDSPACE du fichier de configuration).

« Attention, la seule manière de réinstaller les locales est de réinstaller complètement les paquets Debian correspondants !« 

Pour redéfinir ultérieurement les locales à conserver (si vous changer d’avis..), vous pourrez lancer la commande :

~# dpkg -reconfigure localepurge

04 – Le cache et les logs de vos applications WEB :

Votre navigateur web utilise un cache pour stocker les pages récemment consultées, pour minimiser le temps de chargement si vous y revenez ultérieurement. Ce cache se trouve généralement dans votre répertoire personnel, dans le répertoire de configuration de l’application (~/.mozilla/firefox/xxxxxxxx.default/Cache/ pour Firefox/Iceweasel.). Un rm * dans ce répertoir et le tour est joué !

~# rm * ~/.mozilla/firefox/xxxxxxxx.default/Cache/

De même, le client de messagerie Thunderbird/Icedove, utilise un cache correspondant au répertoire à ~/.thunderbird/xxxxxxxx.default/Cache.

Retenez par ailleurs que bon nombre de clients de messagerie instantanéee stockent par défaut l’ensemble de vos conversations (dans un répertoire ou un fichier « log(s)« . Des services de synchronisation en ligne, tel que Ubuntu One, conservent également des traces des différentes opérations effectuées (dans .cache/ubuntuone/log/ par exemple).

[ASTUCE]

FICHIERS DE SAUVEGARDE :

Il peut également être intéressant de supprimer les éventuels fichiers de sauvegardes automatique, identifiables par le caractère ~ en fin de nom. Pour rechercher ces fichiers, on utilise la commande find :

~$ find ~/ -name ‘*~’

Après avoir vérifié la liste des fichiers retournés par la commande, vous pouvez lancer la suppression de l’ensemble via la commande :

~$ rm -i `find ~/ -name ‘*~’`

L’option -i, falcultative, permet de demander confirmation pour la suppression de chacun des fichiers.

06 ) Gérer les services disponibles :

Identifier les services qui sont lancés au démarrage de votre système, repérer parmi eux les services inutiles pour votre propre usage, savoir les contrôler (les arrêter ou les stopper momentanément), voilà les quelques opérations qui sont abordées ici.

01 – Mais qu’est-ce qu’un service ?

Au démarrage de votre système, de nombreux programmes sont lancés de façon transparente, « en arrière plan », pour vous permettre d’effectuer les tâches habituelles (lancer des applications graphiques, écouter de la musique, accéder à vos différents répertoires, imprimer des documents, naviguer sur le Web,ect.). Ces programmes sont appelés « services » ou encore « démons » ou « daemons« . Chaque distribution fait le choix des services à lancer par défaut dès le démarrage du système.

On distingue plusieurs systèmes de gestion de services au sein des distributions GNU/Linux : System V (le plus ancien, qui tend à disparaître pour être remplacé par l’un des deux suivants), Upstart (intégré à Ubuntu depuis sa version 6.10), et Systemd, le plus récent (intégré à Fedora depuis sa version 15).

Les deux premiers fonctionnent selon des niveaux d’exécution (ou runlevels), Systemd, en revanche, fonctionne sur la base de « cibles » (ou targets). À chaque niveau d’exécution ou cible correspond un mode de fonctionnement du système, dans lequel certains services sont actifs et d’autres non. Et chaque distribution possède un niveau d’exécution ou une cible par défaut. Pour Debian et Ubuntu, il s’agit du niveau 2 ; chez Fedora, il s’agit de la cible graphical.target.

02 –  Gérer les services sur une distribution basée sur System V (ex.Debian) :

Après le processus de démarrage, le tout premier programme lancé, init, exécute tous les scripts de démarrage du  niveau d’exécution par défaut (le niveau 2 dans le cas Debian), situés dans /etc/rc2.d/ : on y trouve les liens pointant vers les scripts des différents services du services du système regroupés dans /etc/init.d/.

Un travail est en cours pour convertir la séquence d’amorçage de Debian, qui permettra à terme au système de démarrer bien plus vite. C’est pourquoi il est possible d’utiliser actuellement plusieurs outils pour gérer les services …

Pour commencer, la commande service permet d’agir sur les scripts de type System V contenus dans /etc/init.d/. Pour obtenir la liste des services disponibles sur le système, on tape :

~# service –status-all

Le [+] signifie que le service tourne ; le [-] signifie que le service n’est pas lancé ; et le [?] que l’état du service ne peut être déterminé ainsi ; on utilisera dans ce cas :

~# /etc/init.d/mysql status

Cette commande permet d’obtenir l’état courant d’un service particulier, que l’on peut visualiser également avec :

~# service apache2 status

Pour gérer les services, on utilisera la commande :

~# service <nom_du_service>
start | stop | restart |reload

ou bien :

~# /etc/init.d/ <nom_du_service>
start | stop | restart | reload

On démarre (start), arrête (stop), redémarre (restart) le service, ou lui demande de relire sa configuration (reload / force-reload).

À présent, voyons comment modifier la liste des services lancés au démarrage du système. Pour ajouter un service (ici le serveur web Apache) à cette liste :

~# update-rc.d apache2 defaults

Quand  l’option defaults est utilisée, update-rc.d crée des liens pour démarrer le service dans les niveaux d’exécution 2,3,4 et 5 et des liens pour arrêter le service dans les niveaux 0,1 et 6.

Depuis Debian 6.0 (Squeeze), on peut utiliser également la commande insserv :

~# insserv apache2

qui prend en paramètre – tout comme les commandes évoquées plus haut – un script exécutable se trouvant dans /etc/init.d/. La commande ne retourne rien si tout se déroule correctement.

Pour faire en sorte qu’un service ne soit plus lancé au démarrage, on utilise l’option -f qui va supprimer tous les liens associés au service en question :

~# update-rc.d -f bluetooth remove

Ou alors :

~# insserv -r bluetooth

Le service bluetooth est alors ôté de tous les niveaux de démarrage ; il ne sera pas démarré au prochain démarrage du système.

Et pour terminer cette partie sur le système, je vous conseil de jeter un oeil de connaître la commande systemd-analyze blame (issue du paquet éponyme) qui liste le temps de démarrage des différents services :

~# systemd-analyze time 

~# systemd-analyze blame 

Voilà que s’achève la partie « système » du chapitre « ligne de commandes« . La prochaine partie concernera le « Multimédia« .

À bientôt …….

Bonjour à tous et bienvenus pour cette « dernière » partie consacrée à la ligne de commande.

Celle-ci sera accès sur un panel de commandes utiles pour une meilleur gestion de votre système via votre terminal.

À commencer par :

► Fichiers :
Comment retrouver rapidement un fichier ? Comment renommer des fichiers par lots ? Comment effacer ses données de façon sécurisée ? Comment manipuler les archives de fichiers ? Comment synchroniser ses données ? Comment manipuler des fichiers PDF ? …

► Système :
Comment gérer les utilisateurs du système et leurs droits ? Comment gérer ses paquets logiciels ? Comment faire le ménage sur son disque dur ? Comment gérer les différents services du système ? Comment identifier précisément son matériel et ses capacités ? …

► Multimédia:
Comment graver un CD/DVD ? Comment retoucher un lot de photos en un tour de main ? Comment enregistrer son bureau pour publier un tutoriel en ligne ? Comment récupérer des vidéos sur les sites de contenus dédiés ?

► Réseau :
Comment identifier et gérer ses interfaces réseaux ? Comment mettre en place une connexion SSH ? Comment visualiser un bureau à distance ? Comment partager ses fichier entre un ordinateur Linux et un autre sous Windows ? Comment automatiser la sauvegarde de ses données ?

01 ► Fichiers.

01 ) Retrouver rapidement un fichier égaré.

Mais si, cela peut arriver bien plus souvent que vous ne le pensez ! Vous créez un document, vous l’enregistrez rapidement sans vraiment regarder où … et impossible de remettre la main dessus ! Ou alors, vous souhaitez éditer le fichier de configuration d’une application, mais vous n’avez aucune idée de l’endroit où il peut être stocké. Ces quelques commandes vont vous aider à retrouver très vite ce que vous cherchez.

01 – Vous connaissez son nom ?

La commande locate permet de localiser instantanément n’importe quel fichier de votre disque, y compris les fichiers cachés. Pour cela, elle s’appuie sur une base de données contenant la liste de tous les fichiers et de tous les répertoires de votre disque (/var/lib/mlocate/mlocate.db).

Pour retrouver un fichier, on indique son nom ou une partie de son nom :

~$ locate profil
/etc/profile
/etc/profile.d
…………………..

Il est nécessaire de mettre régulièrement à jour la base de données utilisée par locate via la commande :

~# updatedb

On pourra penser à configurer  une mise à jour automatique de la base via cron ou anacron.

La commande find parcourt toute l’arborescence du répertoire fourni en paramètre et y recherche le fichier spécifié :

~$ find /home/user/documents -name « monFichier.txt« 

Il est possible d’utiliser des expressions régulières pour spécifier le nom du fichier recherché. Attention, il s’agit ici d’une recherche « exacte« : une recherche du motif « monFic » ne renverra pas « monfichier.txt« .

02 – Vous connaissez une partie du contenu :

La commande grep (une commande que je conseil vivement de connaitre et de maitriser le plus possible) utilise les expressions régulières pour effectuer ses recherches. Elle permet de rechercher une chaîne de caractères dans des fichiers, mais elle est bien souvent utilisée pour filtrer le résultat d’autres commandes en fonction d’un motif particulier.

grep prend en paramètre la chaîne de caractères à rechercher, suivie du nom de fichier dans lequel effectuer la recherche. Par exemple, pour rechercher toutes les lignes du fichier monFichier.txt dont la première lettre est une majuscule :

~$ grep « ^[A-Z] » monFichier.txt

La commande grep retourne alors les lignes correspondant à la recherche demandée. Il est toutefois possible de modifier ce comportement à l’aide d’options :

► -c : retourne le nombre de lignes correspondant à la recherche.

► –color : affiche le motif recherché (ici le « M » majuscule) en couleur.

► -n : retourne les lignes correspondant à la recherche, préfixées par leur numéro.

► -f : permet de passer en paramètre un fichier contenant une liste de motifs à rechercher. Par exemple :
~$ grep -f liste monFichier.txt

► -i : ignore la case dans le motif de recherche et dans le fichier.

Pour lancer la recherche sur l’ensemble des fichiers du répertoire courant, on utilisera le caractère * :

~$ grep « ^[A-Z] » *

Pour parcourir toute l’arborescence de façon récursive, on utilise aux choix l’option -r ou la commande rgrep :

~$ grep -r « ^[A-Z] » *
~$ rgrep « ^[A-Z] » *

03 – Vous avez d’autres critères de recherche ?

La commande find permet d’effectuer la recherche sur bien plus de critères que le simple nom de fichier. Par exemple, vous pouvez rechercher tous les fichiers dont la taille est supérieur à 5Mio et qui ont été modifiés il y a moins de 12 jours grâce aux options -size et -ctime :

~$ find / -size 5M -ctime 12

Notez qu’à chaque fois qu’un fichier correspond à la recherche, il est possible d’exécuter une commande sur celui-ci avec l’option -exec ou -ok.
Imaginons que vous vouliez rechercher puis supprimer toutes les images ISO de votre répertoire personnel. Il suffit d’exécuter :

~$ find . -name « *.iso » -exec rm {} \;

La commande à exécuter (ici rm) suit directement l’option -exec ; les accolades seront remplacées par les noms de fichiers correspondant à la recherche. Le caractère ; indique que la séparation entre les commandes rm se fera à l’aide du point-virgule (notez la présence de l’anti-slash qui permet d’échapper ce caractère). L’option -ok se comporte comme -exec mais vous demande confirmation avant d’exécuter une action.

04 – Vous recherchez un fichier particulier ?

whereis permet de retrouver des fichiers correspondant à des commandes système (fichiers binaires, sources et pages de manuel). Par défaut, elle affiche tous les fichiers associés à une commande, comme dans cet exemple avec la commande yum :

~$ whereis yum
yum : ………………………...

Pour restreindre l’affichage à certains types de fichiers, on utilise les options suivantes : –b : pour les fichiers binaires
-s : pour les sources
-m : pour les pages manuel

05 – Vous recherchez le nom d’un paquet logiciel ?

Lorsqu’on compile une application, il est fréquent d’obtenir un message d’erreur indiquant qu’un fichier d’une librairie est manquant… et il est toujours très pénible de rechercher le nom de la librairie à installer.

Les utilisateurs d’une distribution Debian, Ubuntu ou dérivée pourront utiliser la commande apt-file (à installer au préalable), qui fonctionne à partir d’une base de données que vous mettrez à jour en tapant :

~$ sudo apt-file update

Ensuite, vous n’aurez plus qu’à saisir la commande apt-filesearch, suivie du nom du fichier, comme dans cet exemple :

~$ apt-file search libfftw3.so.3

Le nom du paquet correspondant apparaît en début de ligne ; vous pouvez également visualiser le chemin d’installation.

Les utilisateurs de Fedora quant à eux pourront trouver le nom du paquet auquel appartient un fichier via la commande :

~$ yum provides libfftw3.so.3

La commande dpkg avec l’option -S permet également de savoir à quel paquet appartient un fichier, mais cette fois, la recherche ne concerne que les paquets déjà installés sur votre disque :

~$ dpkg -S libfftw3.so.3

02 ) Renommez proprement vos fichiers.

L’utilitaire detox, présent dans les dépôts logiciels de la plupart des distributions Linux, permet de « nettoyer » et convertir rapidement les noms de fichiers comportant des espaces et des caractères spéciaux, de façon à garantir leur interopérabilité.

detox est également capable de traduire les caractères Latin (ISO 8859-1), les caractères Unicode encodés en UTF-8 et les caractères échappés des chaînes CGI.

01 – Éditer les filtres :

Pour effectuer le « nettoyage », detox utilise plusieurs filtres, dont l’ensemble constitue une « séquence » et qui seront appliqués au fichier passé en paramètre.

Les différentes séquences disponibles sont définies dans le fichier /etc/detoxrc du système, qui sera applicable à l’ensemble des utilisateurs ; il est bien sûr possible de créer votre propre fichier de configuration, ~/.detoxrc, qui peut venir compléter le fichier principal.

On trouve dans ce fichier des séquences comme celles-ci :

~$ cat /etc/detoxrc

On trouve également une liste de fichiers à ignorer :

La séquence nommé default est celle qui sera exécutée si vous ne spécifiez rien ; l’option -s suivie d’un nom de séquence permet d’activer les filtres correspondants.

02 – Exemple de renommage :

Nous allons utiliser ici la séquence defautl pour supprimer les espaces (l’option -v permet d’activer le mode « verbeux » = « voir ce qui se passe pendant…« ) :

~$ detox -v Ce\ Nom\ Comporte\ Des\ Espaces.txt

Puis on supprime les majuscules, avec la séquence lower :

~$ detox -s lower Ce_Nom_Comporte_Des_Espaces.txt

Les séquences disponibles, ainsi que les fichiers ignorés, peuvent être listés via l’option -L ; avec l’option -v, vous visualiserez les filtres qui sont utilisés dans chaque cas :

~$ detox -vL

Très utile également : l’option -n, qui permet de simuler la commande pour observer le résultat que l’on obtiendrait et l’option -r, qui active la récursivité de la commande (elle sera donc appliquée à l’ensemble des fichiers et répertoires contenus dans le répertoire passé en argument).

03 – Les filtres disponibles :

Comme nous l’avons vu, dans chaque séquence sont utilisés un ou plusieurs filtre(s) parmi : safe, wipeup, lower, uncgi, utf_8, ect. La page de manuel de detoxrc nous renseigne quant à leur rôle spécifique. Ainsi, le filtre iso8859_1 traduit les caractères Latin-1 en leurs équivalents ASCII. De même, le filtre utf_8 traduit les caractères Unicode encodés en UTF-8 et le filtre uncgi traduit les caractères CGI échappés dans leurs équivalents ASCII.

Le filtre wipeup permet de s’affranchir de caractères superflus, comme un tiret double ou un underscore double, ou bien une succession de tirets et d’underscores (_-_). Tout cela sera traduit en un seul et unique tiret ou underscore.

Le filtre safe traduit les caractères susceptibles de poser un problème d’interprétation sous Unix : les caractères ` ! @ $ * \ | : ; ‘ ? / sont ainsi traduits en _ et les caractères ( ) [ ] { } traduits en – .

À savoir que ces deux dernier filtres, wipeup et safe, doivent toujours être exécutés après un filtre de traduction (iso8859_1, utf_8, uncgi), afin de s’affranchir du risque d’introduire un caractère illégal dans le nom final du fichier.

Le filtre lower, vu plus haut, permet de transformer toutes les lettres majuscules en minuscules.

Le filtre max_length permet quant à lui de limiter le nombre de caractères du nom du fichier. Bien entendu, ce filtre agit en prenant soin de conserver l’extension du fichier. On pourra l’appliquer comme suit :

Ce qui donne comme résultat :

~$ detox ce_nom_est_beaucoup_trop_long.txt

03 ) Échanger plusieurs fichiers simplement en créant une archive.

Dans un souci d’économie d’espace disque ou bien pour transférer de nombreux fichier en une seule opération et en conservant l’arborescence initiale, la création d’une archive – compressé de surcroît – s’avère particulièrement utile…

01 – Créer une archive de fichiers :

~$ tar -cvf répertoire_à_archiver

Tar est le système d’archivage le plus couramment utilisé sous Linux. L’option -c (create) indique que nous créons une archive, l’option -v (verbose) active le mode verbeux (seront listés à l’écran l’ensemble des répertoires et fichiers placés dans l’archive) et l’option -f (file) introduit le nom de l’archive crée.

~$ tar -rvf mon_archive.tar répertoire_2 fichier.txt

On peut ajouter de nouveaux éléments a posteriori dans une archive existante, grâce à l’option -r et en spécifiant le ou les nouveau(x) fichier(s)/répertoire(s) à ajouter.

~$ tar -Af mon_archive.tar une_autre_archive.tar

Il est également possible d’ajouter un fichier .tar à une archive déjà crée, avec l’option -A. Ici, les fichiers contenus dans une_autre_archive.tar seront concaténés à ceux de mon_archive.tar.

~$ tar -uvf mon_archive.tar répertoire_à_archiver

L’option -u (update) permet d’ajouter uniquement les fichiers qui ont été modifiés depuis la création de l’archive. Ici, on recherche dans répertoire_à_archiver les mises à jour éventuelles, qui remplaceront alors leur ancienne version dans l’archive ; les fichiers qui n’étaient pas déjà présents dans l’archive sont eux aussi ajoutés.

(pensez à toujours créer un répertoire qui contiendra l’ensemble des fichiers et sous-répertoires de votre archive. Ainsi, lors de l’extraction, tous les fichiers seront placés dans un unique répertoire, ce qui sera beaucoup plus propre et plus pratique ! )

02 – Compresser une archive :

~$ tar -czvf mon_archive.tgz répertoire_à_archiver
~$ tar -cjvf mon_archive.tgz répertoire_à_archiver

Pour compresser l’archive à créer, on ajoute simplement l’option -z ou -j, selon si l’on utilise l’outil de compression gzip ou bzip2 respectivement (tous deux pré-installés sur la plupart des distributions)

(le format bzip2 est un format de compression historiquement très utilisé sous Unix, car son taux de compression est meilleur que celui de gzip (mais la compression et le décompression sont plus lentes). Toutefois, bzip2 ne compresse que les fichiers (pas les répertoires).

03 – Lire le contenu d’une archive :

~$ tar -tf archive.tar
~$ tar -tzvf archive.tar.gz
~$ tar -tjvf archive.tar.bz2

On utilise l’option -t, éventuellement accompagnée de l’option -z dans le cas d’une archive compressée avec bzip2. L’option -v (mode verbose) permet de visualiser à l’écran les permissions sur chacun des éléments de l’archive.

04 – Extraire le contenu d’une archive :

~$ tar -xf archive.tar
~$ tar -xzvf archive.tar.gz
~$ tar -xjvf archive.tar.bz2
~$ tar -xkf archive.tar

C’est l’option -x (eXtract) qui permet d’extraire le contenu d’une archive ; encore une fois, on l’accompagne si besoin de l’option -z ou -j selon l’algorithme de compression utilisé. Une autre option qui peut s’avérer utile est l’option -k (–keep-old-files) qui permet de préciser que l’on souhaite pas remplacer les fichiers existants lors de l’extraction.

05 – Cas du format ZIP :

~$ zip -rv mon_archive.zip répertoire_à_archiver

Il est également possible de créer une archive compressée à l’aide de la commande zip. L’option -r (recursive) implique une descente récursive dans les répertoires, l’option -v (facultative) permet comme à l’habitude de visualiser la liste des fichiers intégrés dans l’archive.

~$ zip -rvu mon_archive.zip répertoire_à_archiver

Pour ajouter des fichiers ou mettre des fichiers de l’archive, on utilise l’option -u ; on recherche ici les nouveaux fichiers et les fichiers qui ont été modifiés dans répertoire_à_archiver

~$ unzip archive.zip

La commande unzip permet de décompresser et d’extraire les fichiers contenus dans une archive .zip. À noter que l’option -e (encrypt) permet de protéger votre archive par un mot de passe lors de la création. Pour décompresser une telle archive, vous devrez bien sûr être en possession de ce mot de passe …

06 – Cas du format 7z :

L’outil p7zip supporte de très nombreux formats d’archive et de compression ; selon les distributions, vous le trouverez dans les dépôts logiciels sous le nom p7zip, p7zip-full et p7zip-rar. Les deux premiers paquetages se différencient par le nombre de formats pris en charge et le dernier ajoute le support du format rar.

~$ 7z mon_archive répertoire_à_archiver

Pour créer une nouvelle archive, on utilise l’option a (add) suivie du nom de l’archive (l’extension .7z est ajoutée automatiquement), et des noms de fichiers/répertoires à y inclure ; la récursivité est implicite. Pour protéger l’archive par un mot de passe, on ajoute l’option -p suivie du mot de passe (qui sera demandé pour l’extraction).

~$ 7z u mon_archive.7z répertoire_à_archiver nouveau_répertoire/fichier

L’option u (update) permet d’ajouter de nouveaux fichiers et d’enregistrer les modifications effectuées sur les fichiers déjà présents dans l’archive .

~$ 7z l mon_archive.7z

L’option l (list) permet de lister le contenu de l’archive.

~$ 7z x mon_archive.7z

L’extraction des fichiers s’effectue via l’option x (extract).

07 – Cas du format RAR :

~$ unrar x une_archive.rar

Pour extraire le contenu d’archives .rar, on utilise la commande unrar (issue du paquet éponyme). L’extraction s’effectue via l’option x ; on listera le contenu de l’archive avec l’option l .

04 ) Récupérez vos fichiers effacés !

Vous avez effacé par mégarde les photos de la carte mémoire de votre appareil ou bien formaté une partition qui contenait des données très importantes ? Inutile de pleurer toutes les larmes de votre corps, cela ne fera pas ré-apparaître vos fichiers ! PhotoRec en revanche, lui, le pourra.

PhotoRec est un programme conçu à l’origine pour récupérer les photos effacées des cartes mémoire d’appareil photos (d’où son nom, de l’anglais, Photo Recovery). Aujourd’hui, il est capable de récupérer plus d »une centaine de formats de fichiers différents (images,vidéos,archives,documents…). Il fonctionne avec des disques durs, CD ROM, CompactFlash, Memory Stick, SecureDigital, SmartMedia, MicroDrive, MMC, USB Memory Drives…

PhotoRec se trouve dans les dépôts de la plupart des distributions, vous pourrez donc l’installer très facilement via votre gestionnaire de paquets habituel. On le lance tout simplement via la commande (en tant que root) :

~# photorec

Les options :

► Paranoid : activée par défaut, permet de vérifier les fichiers récupérés ; les fichiers invalides sont rejetés. Pour récupérer davantage de JPEG fragmentés, vous pouvez activer le Brute force (qui est beaucoup plus gourmand en ressources processeur).

► Allow partial last cylinder : désactivée par défaut, modifie la façon dont la géométrie du disque est déterminée (cela n’affecte que les volumes non partitionnés).

► Keep corrupted files : désactivée par défaut, elle conserve les fichiers récupérés même s’ils sont endommagés.

► Expert mode : désactivée par défaut, permet de forcer la taille de bloc utilise et l’offset. Sur un disque entier ou une partition reformatée, si PhotoRec retrouve peu de fichiers, vous pouvez essayer la valeur minimale que PhotoRec propose (il s’agit de la taille d’un secteur, 0 sera alors utilisé pour l’offset).

► Low memory : désactivée par défaut, vient pallier le manque de mémoire éventuel de votre système (à n’utiliser qu’en cas de systèmes de fichiers très volumineux et très fragmentés).

01 – Choix du média :

Le programme commence par vous demander de séléctionner le média concerné ; vous effectuez la sélection à l’aide des touches fléchées, puis validez votre choix avec la touche [Entrée]. On choisi la carte mémoire de notre appareil, identifiée ici par /dev/sda .

02 – Choix de la partition :

PhotoRec dresse ensuite la liste des partitions sur le média ; choisissez celle que vous souhaitez, ou bien lancez le programme sur l’ensemble du disque (1er choix de la liste).

Remarquez au bas de l’écran l’item [File Opt] : il mène à une liste de formats de fichiers. En effet, il est possible d’affiner la recherche en ne sélectionnant qu’un ou quelques format(s) de fichiers. La sélection s’effectue à l’aide de la barre d’espace. De même, l’item [Options] permet d’accéder aux diverses options du programme et éventuellement de les modifier. Retournez sur [Search], pour passer à l’étape suivante.

File options

Options

Search

03 – Système de fichiers :

Vous devez ensuite indiquer à PhotoRec dans quel type de système de fichiers se trouvent les fichiers effacés. Les systèmes de fichiers ext2 à ext4 sont traités de manière spécifique, d’où la nécessité du choix par l’utilisateur.

04 – Étendue de la recherche :

L’étape suivante vous invite à choisir si la recherche doit être effectuée sur toute la partition (Whole) ou bien seulement sur l’espace non alloué (Free).

05 – Stockage des fichiers :

Vous devez ensuite indiquer où PhotoRec doit stocker les fichiers retrouvés. Typiquement, on créera à cet effet un répertoire nommé « sauvegarde » ou « backup » à l’endroit de son choix. Attention : évitez de choisir ici un emplacement sur le disque qui fait justement l’objet de la recherche ! Naviguez dans l’arborescence de fichiers à l’aide des touches fléchées, puis tapez [C] lorsque votre choix est fait.

06 – Progression :

Et PhotoRec s’exécute ! Vous pouvez visualiser le temps restant estimé pour scanner le disque. Les fichiers retrouvés sont listés au fur et à mesure, classés par format, et sont stockés dans le répertoire que vous avez indiqué plus haut. Il vous suffira de le parcourir pour retrouver vos précieuses données. Notez que les noms de fichiers, eux, ne sont pas récupérés, mais avouez que c’est un moindre mal …

05 ) Effacer vos données de façon définitive et sécurisée.

Vous devez changer de poste de travail, ou vous séparer d’un disque dur ? Immédiatement vous pensez à toutes ces données personnelles et/ou sensibles qui traînent encore sûrement sur vos supports de stockage. Vous trouverez ici plusieurs méthodes permettant d’effacer complétement vos données sans laisser la moindre trace…

01 – Pourquoi faire plus compliqué que [Suppr] ?

Lorsqu’on supprime un fichier, qu’on vide la corbeille, ou qu’on formate une partition, le système signale dans la table d’allocation des fichiers que les clusters qui étaient jusque-là occupés sont désormais disponibles…Et c’est tout ! Les données, elles ne sont pas physiquement effacées. Par analogie, c’est comme si l’on supprimait un chapitre dans le sommaire d’un ouvrage, sans retirer le chapitre lui-même. Ainsi, ces données peuvent potentiellement être récupérées avec des outils appropriés…

De ce fait, le seul moyen de supprimer (pour de vrai) des données consiste à ré-écrire sur les secteurs à effacer ; on parle d’effacement « par sur-charge ».

Pourquoi une telle persistance des données ? Un disque dur est constitué d’aimants et ces derniers peuvent en quelque sorte « mémoriser » l’état antérieur du disque (du moins, une partie). On appelle cela le phénomène de rémanence. Ainsi, même si vous remplissez votre disque de zéros, il existe des techniques et outils (par exemple PhotoRec, présenté plus haut) pour accéder aux données retenues par les aimants. Ces traces résiduelles sont dues au fait que la tête d’écriture du disque n’est pas toujours parfaitement alignée sur sa piste ; elle écrit donc souvent un peu à gauche et à droite de la piste.

02 – Effacer un disque :

Avant de se lancer dans l’effacement d’un disque, on commence par identifier correctement le disque en question :

~# fdisk -l

La commande dd :

Issue du paquet coreutils, la commande dd (device to device) permet de copier bloc par bloc un fichier de périphérique vers un autre fichier de périphérique ou quelconque.

Pour effacer tout le disque en réinitialisant toutes les données à 0 :

~# dd if=/dev/zero of=/dev/sda

Pour effacer tout le disque en écrasant les données existantes avec les données aléatoires :

~# dd if=/dev/urandom of=/dev/sda

L’option if introduit le fichier à copier (ici /dev/zero ou /dev/urandom) et of indique le fichier résultant de la copie.

On pourra réduire le temps de chaque passe à l’aide de l’option bs, qui permet de spécifier le nombre d’octets (512 par défaut) écrits en une seule fois (par exemple, bs=1024).

Toutefois, l’utilisation de dd ne garantit pas à 100% l’effacement des données sensibles, comme nous l’avons expliqué en introduction.

La commande shred :

L’utilisation de la commande shred permet de contrer l’effet de rémanence ; elle consiste à écrire plusieurs fois un motif différent sur le même fichier. On pourra l’utiliser pour un fichier régulier, comme pour un fichier de périphérique.

~# shred -vfz -n 3 /dev/sda
shred: /dev/sda : passe 1/4 (random) …
shred: /dev/sda : passe 1/4
………………………………
……………………………………..

L’option -v permet, comme d’habitude, d’activer le mode verbeux. L’option -f permet de « forcer » l’opération, autrement dit, elle autorise shred à modifier les permissions du fichier si nécessaire. L’option -z écrit des zéros lors d’une dernière passe pour camoufler le déchiquetage du fichier. L’option -n introduit le nombre de passes (3 par défaut).

Attention : comme le souligne la page du manuel du programme (man shred), le déchiquetage considère que le système de fichiers écrasera les données sur place. Or, plusieurs structures de systèmes de fichiers ne remplissent pas cette condition. Ainsi, shred ne fonctionne pas (ou pas dans tous les modes) sur les systèmes suivants :

► les systèmes de fichiers journalisés ou à structure de journalisation (JFS, ReiserFS, XFS, ext3, ect).

► les systèmes de fichiers avec écriture redondante et continuant à écrire même en cas d’erreur (RAID).

► les systèmes de fichiers qui effectuent des instantanés (serveur NFS de Network Appliance).

► les systèmes de fichiers qui mettent en cache dans des dossiers temporaires (clients NFS version 3).

► les systèmes de fichiers compréssés.

On apprend ainsi que dans le cas du système ext3, très couramment utilisé sous Linux, shred sera d’une efficacité limitée dans le mode data=journal (mode dans lequel les données sont inscrites dans le journal avant d’être écrites dans le système de fichiers principal) ; en revanche, shred fonctionnera tout à fait normalement dans les modes data=ordered (le mode par défaut, dans lequel les données sont envoyées au système de fichiers avant l’écriture des métadonnées dans le journal) et data=writeback.

À savoir que le mode de journalisation d’un système ext3 peut être contrôlé en ajoutant l’option data= aux options de montage de l’arborescence dans le fichier /etc/fstab.

03 – Effacer un fichier sensible avec wipe :

Pour effacer des fichiers réguliers de façon sécurisée, on pourra se tourner vers d’autres outils plus adaptés, wipe est l’un d’entre deux et se trouve dans les dépôts de la plupart des distributions ; on l’utilisera comme suit :

~$ wipe -r -i -q rep_à_effacer/

L’option -r supprime l’ensemble du répertoire de façon récursive ; -i active le mode verbeux ; l’option -q permet de spécifier le nombre de passes (4 par défaut). L’option -c permet de modifier le spermissions sur les fichiers qui le nécessitent.

06 ) Synchronisez le contenu de vos fichiers ! 

Vous avez pour habitude de rapporter du travail à la maison ? Vous multipliez ainsi les versions de fichiers sans plus vous y retrouver ? Il est temps de vous organiser et d’opter pour la synchronisation de vos données …..

Le programme Unison permet de répliquer un ensemble de fichiers et/ou répertoires sur différentes machines ou différents disques de la même machine.
Compatible Unix et Windows, il permet de réaliser une synchronisation de fichiers entre ces deux types de système. Unison peut en outre être utilis pour les synchronisations à distance, via le protocole SSH.

Unison devra être installé sur chaque machine à synchroniser ; il est packagé pour la plupart des distributions. Nous distinguerons ici deux cas typiques : une synchronisation locale de deux répertoires et une synchronisation à distance.

01 – Synchronisation locale :

Imaginons que vous rentriez du travail avec votre clé USB contenant le dossier sur lequel vous avez travaillé toute la journée ; vous souhaitez synchroniser son contenu avec celui du dossier stocké sur votre ordinateur personnel, à la maison. Voici la commande à exécuter :

~$ unison -ui text /media/usbkey/rep1 /home/user/rep2 
Contacting server ……
……………………………
………………………………….

L’option -ui text utilisée ici nous permet de forcer l’utilisation en ligne de commandes d’Unison, sinon l’interface graphique se lance automatiquement (ce comportement dépend toutefois du binaire utilisé par votre distribution et vous ne serez peut être pas obligé d’utiliser cette option pour archiver le mode console).

La commande ne retourne rien pour l’instant étant donné qu’il s’agit de la première synchronisation de nos deux répertoires ; aucun changement n’est à noter.

À présent nous allons ajouter un nouveau fichier dans chacun des répertoires, puis lancer la synchronisation de ces derniers :

~$ unison -ui text /media/usbkey/rep1 /home/user/rep2
Contacting server…..
……………………………
…………………………………

Le programme liste les modifications une à une en vous demandant à chaque fois de préciser l’action à réaliser. Pour ce faire :

► la touche [f] pour follow, permet de valider la suggestion formulée par Unison (dans l’exemple ci-dessus, on valide la copie du fichier nommé file1 dans rep2) .

► les touches [<] et [>] permettent de modifier le sens de propagation.

► la touche [/] permet d’ignorer la modification et de ne rien faire.

La liste des modifications continue ainsi, jusqu’à l’exécution des actions en attente pour laquelle une confirmation vous est demandée :

Proceed with propagating updates? [] 

Plusieurs réponses sont possibles ici :

► [y] ou [g] pour valider vos choix.

► [n] pour revenir aux sélections.

► [q] pour quitter le programme sans propager les modifications.

Si un même fichier se trouve dans chacun des répertoires, mais sous une version différente, Unison se trouve face à un conflit qu’il ne peut résoudre seul ; ceci est symbolisé par un point d’interrogation.

Par défaut, aucune action n’est réalisée et chacun demeure dans sa version d’origine.

Dans ce cas, la touche [d] permet d’afficher les différences entre les deux fichiers, [x] affiche des détails sur les fichiers (date de dernière modification, taille et permissions) et [m] permet de fusionner les fichiers.

02 – Synchronisation à distance :

Une connexion SSH doit être mise en place entre les deux machines ; chacune pourra servir à la fois de client et de serveur selon l’endroit où vous vous situez lors de la synchronisation. On veillera par ailleurs à ce que les versions d’Unison sur les deux machines concernées soient identiques (via la commande unison -version) .

Considérons une machine A sur laquelle se trouve dans votre répertoire personnel un répertoire repA, que l’on souhaite synchroniser avec un répertoire repB se trouvant sur une machine B. On utilisera une commande du type :

~$ unison repA ssh://IP_machine_distante/repB

Si repB se trouve ailleurs que dans votre répertoire personnel sur la machine distante, il faudra spécifier le chemin absolu vers ce répertoire en ajoutant un slash supplémentaire :

~$ unison repA ssh://IP_machine_distante//chemin/vers/repB

Si le nom d’utilisateur sur la machine distante n’est pas le même qu’en local, on utilisera la syntaxe :

~$ unison repA ssh://username@IP_machine_distante/repB

Il vous est alors demandé de saisir le mot de passe de la machine distante. Les modifications apparaissent quant à elles de manière tout à fait similaire au cas de la synchronisation locale.

03 – Créer des profils de synchronisation :

Le répertoire ~/.unison contient un fichier default.prf (vide par défaut). Ce type de fichier permet de définir des profils de synchronisation ; on peut y définir les deux chemins absolus des répertoires à synchroniser, avec la variable root.

Par exemple, si je souhaite synchroniser de façon récurrente les répertoires rep1 ou rep2 sur ma machine, je crée un fichier replocal.prf contenant :

root = /home/user/rep1
root = /home/user/rep2

Puis, pour lancer la synchronisation ultérieurement, il faudra exécuter :

~$ unison replocal

Bien entendu, un profil peut aussi contenir un chemin vers un répertoire distant, par exemple :

root = /home/user/Documents/WIP
root= ssh://IP_machine_distante/TAF/WIP

D’autres options peuvent être consignées dans un profil. Parmi les plus intéressantes :

# Pour préciser les fichiers à synchroniser (si l’on ne souhaite synchroniser qu’une partie des fichiers contenus dans l’arborescence définie pour la variable root)
path =
# Pour préciser les fichiers à ignorer lors de la synchronisation 
ignore =
# Pour accepter automatiquement les actions par défaut (en cas de modifications non conflictuelles)
auto = true
# Pour éviter toute question à l’utilisateur 
batch = true

La commande unison -help affiche l’ensemble des options disponibles.

07 ) Découpez, (ré)assemblez ou agrémentez vos documents PDF !

Le format PDF (Portable Document format), crée par Adobe Systems en 1993, est très largement utilisé, notamment dans un contexte professionnel, car il présente de nombreux avantages : il préserve les polices, les éléments graphiques et toute la mise en page d’un document quel que soit le logiciel utilisé pour le visualiser. Voici quelques commandes à retenir pour manipuler vos documents PDF.

01 – Coupez, triez, assemblez vos documents !

pdftk est souvent présenté comme le « couteau suisse » du format PDF. Et pour cause ! Il offre énormément de possibilités : fusion, découpage, rotation, chiffrement, attachement de fichiers, apposition d’un watermark, ect.

Pour fusionner plusieurs documents :

~$ pdftk doc1.pdf doc2.pdf doc3.pdf cat output fusion123.pdf

L’option cat permet de concaténer les documents passés en paramètres pour créer un nouveau PDF ; l’option output introduit le nom du document résultant. Le caractère * peut bien sûr être utilisé pour désigner l’ensemble des PDF du répertoire courant :

~$ pdftk *.pdf cat output fusion.pdf

Pour ne sélectionner que certaines pages de différents documents, puis les ré-assembler dans l’ordre spécifié dans un nouveau document :

~$ pdftk A=doc1.pdf B=doc2.pdf cat A1-3 B2-8 A5 output fusion.pdf

Nos pages demandées (3 pour le PDF 1 et 8 pour le PDF 2) ont bien été  assemblées dans un nouveau et même PDF nommé « fusion.pdf » (ce qui nous fait un total de 11 pages comme le montre l’image ci-dessous). Je sais pas pour vous si vous avez déjà essayé de modifier un PDF sous Windows, mais croyez moi, ce n’est pas aussi « simple » ….

Il est aussi possible de faire pivoter l’ensemble des pages d’un documents :

~$ pdftk doc.pdf cat 1-endE output doc_final.pdf

L’angle de rotation est défini par une « simple » lettre (N=0, E=90°, S=180°, W=270°, L=90, R=+90, D=+180). Notez ici l’utilisation du mot-clé end qui désigne la dernière page du document ; de même, even et odd peuvent être utilisés pour désigner respectivement les pages paires et impaires.

Pour découper un PDF en pages individuelles :

~$ pdftk doc.pdf burst

Normalement, nous devrions avoir notre PDF découpé en 11 pages. Allons voir ça ….

C’est bien le cas.  

Si vous n’utilisez pas l’option output, chaque page créée sera nommé pg_0001.pdf, pg_0002.pdf, ect, comme vous pouvez le voir sur l’image ci-dessus. À vous de spécifier un format de nommage selon votre besoin.

~$ pdftk doc.pdf burst output page_%02d.pdf

02 – Chiffrer un document :

Pour chiffrer un document PDF avec une clé de 128 bits (valeur par défaut), tout en conservant l’ensemble des permissions, on saisira :

~$ pdftk doc.pdf output doc_secret.pdf owner_pw

On ajoutera l’option allow printing en fin de ligne pour autoriser l’impression du document.

Puis, pour déchiffrer le document :

~$ pdftk doc_secret.pdf input_pw output doc.pdf

03 – Ajouter un filigrane (watermark) :

Ceci se réalise à l’aide de l’option background, directement suivie du document comportant le filigrane (à créer).

~$ pdftk doc.pdf background mon_filigrane.pdf output doc_final.pdf

La première page du filigrane est appliquée sur chacune des pages du document d’entrée (si nécessaire, elle est redimensionnée et/ou pivotée pour s’appliquer au mieux sur le document). Notez que si le document d’entrée ne comporte pas d’arrière-plan transparent (c’est le cas des PDF générés à partir de pages scannées), l’arrière-plan ne sera pas visible ; il est alors nécessaire d’utiliser l’option stamp à la place de background.

04 – Agrandir un document :

pdfposter permet de répartir votre document PDF sur plusieurs pages pour en faire un poster une fois les pages assemblées.

~$ pdfposter -ma3 -pa0 doc.pdf poster.pdf

On crée ici un poster de taille A0, constitué de pages A3, à partir d’un document PDF au format A4. L’option -m permet de définir la taille du média d’impression (A4 par défaut) : l’option -p permet de spécifier la taille du poster final. Les dimensions peuvent être exprimées de façon numérique ou via le nom du média. Pour voir la liste des différents médias :

~$ pdfposter –help-media-names

On peut utiliser aussi l’option -s pour spécifier un facteur de redimensionnement ; la taille du poster final sera déterminée automatiquement, inutile donc d’utiliser l’option -p simultanément :

~$ pdfposter -s4 doc.pdf poster.pdf

L’option -n permet de simuler la commande sans générer les fichiers.

05 – Améliorez vos présentations !

pdfcube (dans les dépôts Debian et Ubuntu) permet de visionner un fichier PDF en incluant des transittions 3D entre les pages. Pour visualiser un document PDF de cette façon :

~$ pdfcube doc.pdf

avant … :

après … :

Votre document apparait alors en plein écran ; pour passer en mode fenêtré, utilisez la touche [F]. Les touches [A] et [C] permettent de passer d’une page à l’autre. Il est possible de programmer les transitions à l’avance, comme suit :

~$ pdfcube doc.pdf 2 5 7

Ici, le 2 signifie « entre la page 3 et 4 », le 5 signifie « entre la page 6 et 7 », ect.

Vous pourrez en outre zoomer sur les coins et le centre du document, via les touches [H], [J], [K], [L] et [Z] (pour sortir du mode zoom, il suffit d’appuyer sur la même touche). La barre d’espace vous fait passer à la page suivante avec l’effet de transition programmé ; les touches [Pg.Prèc] et [Pg.Suiv] permettent de passer à la page suivante ou précédente sans effet particulier, de même que les touches fléchées. Enfin, la touche [Échap] permet de quitter l’application.

Pour modifier les couleurs d’arrière plan (option -b) et de la face supérieure du cube (option -t) :

~$ pdfcube doc.pdf -b 0,0,0 -t 0,6,0,2,0,2

Les couleurs sont définies en valeur R.G.B (valeurs entières comprises entre 0 et 1, sans espace).

La commande wiipdf(dans les dépôts Debian et Ubuntu) permet quant à elle de contrôler la présentation d’un document PDF avec Xpdf avec une Wiimote (dépendance requise : libcwiid1). Elle prend en argument l’identifiant Bluetooth de votre Wiimote (à déterminer à l’aide de hcitool), suivi du chemin vers le fichier PDF à présenter. Pressez simultanément les boutons 1 et 2 de la télécommande pour entrer dans le mode détectable. Quand la connexion est établie, wiipdf ouvre le document dans Xpdf, en plein écran. Vous pouvez alors passer d’une page à l’autre via les boutons A et B de la Wiimote ; le bouton « HOME » permet de mettre fin à la présentation.

~$ wiipdf 00:25:A0:C0:CF:CB doc.pdf

06 – Du HTML au PDF :

wkhtmltopdf est un utilitaire qui, comme son nom l’indique, sert à convertir une ou plusieurs pages(s) HTML en document PDF :

~$ wkhtmltopdf -g -l <url> doc.pdf

On génère ici un PDF en noir et blanc (option -g, pour grayscale) et en basse résolution (option -l pour lowquality). À savoir que l’option -O <orientation> permet de préciser l’orientation Portrait (par défaut) ou Landscape (paysage). On peut définir du papier via l’option -s <size> (A4 par défaut).

Voilà, nous avons terminé avec la première partie du chapitre « ligne de commandes » concernant « les fichiers« . La deuxième parties sera accès sur le « système« . 

À très vite …..

Pirater Windows 10 avec 2 touches…. Non seulement les logiciels de Microsoft sont pleins de failles de sécurité, mais parfois ces failles sont « rigolotes ». Sam Laiho, un expert du système d’exploitation de la maison, a découvert qu’il suffit d’appuyer en même temps sur les touches [Shift] + F10 pendant une mise à jour de Windows 10 pour obtenir les droits administrateur sur le système.

La combinaison de touches permet d’avoir accès à la ligne de commande et au disque principal et au disque principal, car BitLocker censé protéger la machine est désactivé pendant la mise à jour (…ouais). Pour améliorer la sécurité de vos machines face aux pirates cagoulés, nous vous proposons de supprimer la touche [Shift] et F10 de tous les clavier !

À suivre …..

Source.

 

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 ….