Étiquette : gnu

Catégories
Open-source Planet-libre Systeme

Supervision simple en ligne de commande avec Saidar

Marre des interfaces graphiques qui ne sont là que pour faire plaisir à vos chefs ? Marre de passer vos journées dans les méandres des fichiers de configuration de Nagios ? Vous avez besoin d’un moyen simple et rapide pour voir ce qui cloche sur une machine ?

Si vous avez répondu oui aux questions précédentes ou que comme moi la première chose que vous faites en cas de problème sur une machine est de regarder la charge, la mémoire et l’espace disque disponible  alors Saidar est fait pour vous !

C’est quoi donc ?

Saidar est un logiciel libre (GPL v2), en ligne de commande permettant d’afficher sur dans une console l’état de votre machine. Il se base sur la librairie libstatgrab qui apporte une couche d’abstraction pour la récupération des informations sur les systèmes d’exploitations Solaris 2.x, Linux 2.2/2.4/2.6, FreeBSD 4.x/5.x, NetBSD 1.6.x, OpenBSD 3.x, DragonFly BSD 1.0, HP-UX, et Cygwin (donc Windows).

Cette librairie dispose également de binfing (interface) vers les langages suivants:

Comment cela marche ?

Sous Debian/Ubuntu, l’installation est facilité par la présence de Saidar dans les dépôts officiels:

[cc lang= »bash »]

# apt-get install saidar

[/cc]

Il suffit ensuite de lancer le logiciel depuis une console (/ terminal):

[cc lang= »bash »]

# saidar

[/cc]

Pour voir afficher les merveilleuses statistiques:

Personnellement j’ai ajouté un raccourci à mon fichier .bashrc pour activer certaines options (couleur et rafraîchissement toute les secondes):

[cc lang= »bash »]

alias saidar=’saidar -c -d 1′

[/cc]

Et voilà le résultat:

Si un chiffre apparaît en gras, c’est que la valeur dépasse les 60%. Au dessus de 90% il est affiché en avec un fond de couleur.

Bref, un outil bien sympathique dans l’esprit GNU à laisser tourner sur vos machines critiques !

Catégories
Open-source Planet-libre Systeme

Script de post installation de Mint 12 (aka Lisa)

L’utilisation par défaut de l’environnement Unity dans la dernière version d’Ubuntu (la 11.10) a beaucoup fait parler d’elle dans le petit monde des utilisateurs GNU/Linux. En effet, cette nouvelle interface demande à l’utilisateur une période d’adaptation pour retrouver ses marques. Personnellement, j’ai dans un premier temps renoncé à l’utiliser sur mon PC personnel mais pas pour cette raison. Comme j’utilise des distributions diverses et variées (Debian, Fedora, Ubuntu, BSD…), je souhaite avoir un environnement similaire entre tous ces systèmes. Comme Unity est seulement utilisée dans l’écosystème Ubuntu, je me suis penché sur Gnome 3 (Gnome Shell) et je l’ai donc installé puis configuré sur mon Laptop perso.

Aujourd’hui sort Mint 12 (« Lisa »), une distribution GNU/Linux basée sur Ubuntu (11.10) mais avec Gnome Shell comme environnement graphique par défaut. J’ai donc installé cette distribution sur une de mes machines et je dois avouer que j’ai été assez bluffé par le degré et la maturité d’intégration de Gnome Shell.

J’en ai également profité pour écrire un script de post installation qui permet de peaufiner le système en installant des logiciels manquants (voir la liste ici) et en améliorant encore un peu plus Gnome Shell (installation de thèmes et d’icônes supplémentaires).

Le script est disponible sur le repo GitHub (lien direct pour le téléchargement).

Pour exécuter le script sur une Mint fraichement (hahaha) installée:

[cc lang= »bash »]
mkdir ~/install
cd ~/install
wget https://raw.github.com/nicolargo/ubuntupostinstall/master/mint-12-postinstall.sh
chmod a+x mint-12-postinstall.sh
sudo ./mint-12-postinstall.sh
[/cc]

Voici le résultat:

Je suis bien sûr preneur de toutes les remarques sur le script. Vous pouvez également contribuer à son évolution en suivant ce tutoriel.

Avec quelques jours de recul, je pense le plus grand bien de cette distribution, elle apporte une cohérence et une continuité au niveau de l’interface graphique que l’on ne retrouve pas (ou plus) chez Ubuntu.

Avez-vous essayé Mint ? Qu’en pensez-vous ?

Catégories
Open-source Planet-libre Reseau

Installation d’un serveur de temps sur votre réseau

Dans un système d’information moderne, la synchronisation des machines sur une horloge commune est un pré-requis pour de nombreuses actions comme l’analyse des logs ou la supervision système et réseau. Si vos machines sont directement connectés à Internet alors il n’y a pas de problème car les distributions GNU/Linux, Windows et Mac OS X embarquent des mécanisme pour se mettre automatiquement à l’heure en se synchronisant sur des serveurs publics (par exemple 0.debian.pool.ntp.org sur une Debian Squeeze). Si ce n’est pas le cas et que vos machines sont isolées et/ou bien filtrées lors de leurs accès à Internet, il peut être intéressant d’installer un serveur de temps local sur une de vos machine.

Nous allons donc dans ce billet installer un serveur de temps NTP sur une machine sous Debian 6 (Squeeze).

Le protocole NTP

J’invoque le bon génie Wikipédia: « Le Protocole d’Heure Réseau (Network Time Protocol ou NTP) est un protocole qui permet de synchroniser, via un réseau informatique, l’horloge locale d’ordinateurs sur une référence d’heure. »

La référence en question sera donc, dans notre cas, la machine ou nous allons installer puis configurer notre serveur NTP.

Le protocole NTP utilise le port UDP/123 pour effectuer les requêtes sur le réseau. Notre serveur sera donc en écoute sur le port UDP 123 (si vous avez un Firewall, il faudra bien entendu le configurer pour autoriser les requêtes sur ce port).

Installation du serveur NTP

On commence par installer les paquets nécessaires dans une console root:

[cc lang= »bash »]

apt-get install ntp ntpdate

[/cc]

La première chose à faire est de mettre le serveur à la bonne heure (quitte à avoir une référence, autant qu’elle soit juste…).

Pour cela deux solutions:

  • si votre machine à accès à Internet, utiliser la commande « ntpdate-debian » qui va synchroniser votre machine sur les serveur NTP Debian.
  • si votre machine n’a pas accès à Internet, alors téléphoner à l’horloge parlante (numéro payant: 3699) puis configurer l’heure système avec la commande « date ». Par exemple « date -s 16:56:23 ».

On édite ensuite le fichier /etc/ntp.conf:

[cc lang= »bash »]

# /etc/ntp.conf, configuration for ntpd; see ntp.conf(5) for help

driftfile /var/lib/ntp/ntp.drift

# Enable this if you want statistics to be logged.

#statsdir /var/log/ntpstats/

statistics loopstats peerstats clockstats

filegen loopstats file loopstats type day enable

filegen peerstats file peerstats type day enable

filegen clockstats file clockstats type day enable

# You do need to talk to an NTP server or two (or three).

#server ntp.your-provider.example

# http://www.pool.ntp.org/zone/fr

server 0.fr.pool.ntp.org

server 1.fr.pool.ntp.org

server 2.fr.pool.ntp.org

server 3.fr.pool.ntp.org

# pool.ntp.org maps to about 1000 low-stratum NTP servers. Your server will

# pick a different set every time it starts up. Please consider joining the

# pool: <http://www.pool.ntp.org/join.html>

# Access control configuration; see /usr/share/doc/ntp-doc/html/accopt.html for

# details. The web page <http://support.ntp.org/bin/view/Support/AccessRestrictions>

# might also be helpful.

#

# Note that « restrict » applies to both servers and clients, so a configuration

# that might be intended to block requests from certain clients could also end

# up blocking replies from your own upstream servers.

# By default, exchange time with everybody, but don’t allow configuration.

restrict -4 default kod notrap nomodify nopeer noquery

restrict -6 default kod notrap nomodify nopeer noquery

# Local users may interrogate the ntp server more closely.

restrict 127.0.0.1

restrict ::1

# Clients from this (example!) subnet have unlimited access, but only if

# cryptographically authenticated.

#restrict 192.168.123.0 mask 255.255.255.0 notrust

# My server is a public server

restrict 0.0.0.0 mask 0.0.0.0

# If you want to provide time to your local subnet, change the next line.

# (Again, the address is an example only.)

broadcast 192.168.123.255

# If you want to listen to time broadcasts on your local subnet, de-comment the

# next lines. Please do this only if you trust everybody on the network!

#disable auth

#broadcastclient

[/cc]

Les informations intéressantes sont les suivantes:

server 0.fr.pool.ntp.org

server 1.fr.pool.ntp.org

server 2.fr.pool.ntp.org

server 3.fr.pool.ntp.org

Permet de configurer les serveurs maîtres sur lesquels votre machine va essayer de se synchroniser pour rester à l’heure. Il faut bien sûr que votre machine est accès à Internet sur le port UDP/123.

restrict 0.0.0.0 mask 0.0.0.0

On rends notre serveur public, toutes les machines ayant un accès réseau (encore une fois sur le port UDP/123) pourront se synchroniser à partir de votre serveur. Il est bien sûr possible de limiter ce droit aux seules machines de vos réseaux.

broadcast 192.168.0.255

(optionnel) Diffuse le temps sur l’adresse de broadcast de votre réseau (par exemple 192.168.0.0/24).

On relance ensuite le serveur pour que la configuration soit prise en compte:

[cc lang= »bash »]

# /etc/init.d/ntp restart

Stopping NTP server: ntpd.

Starting NTP server: ntpd.

[/cc]

Synchroniser vos machines avec votre serveur NTP

La configuration des clients est relativement simple car souvent inclus dans les « wizards » d’installations. Il suffit de préciser l’adresse IP ou le nom de votre machine hébergeant le serveur NTP comme serveur de temps.

Sur un client Debian 6 existant, il faut installer le package suivant (en root):

[cc lang= »bash »]

apt-get install ntpdate

[/cc]

Puis lancer la commande suivante (si votre serveur de temps est hébergé sur la machine 192.168.0.100):

[cc lang= »bash »]

ntpdate -dv 192.168.0.100

[/cc]

Conclusion

Le protocole NTP étant normalisé, il est bien sur possible de synchroniser toutes vos machines (Linux, BSD, Windows, OS X…) sur votre nouveau serveur de temps.

Catégories
Nagios Open-source Planet-libre Web

Twitter en ligne de commande (même avec oAuth)

Il y a quelque temps, j’avais écrit un billet sur comment envoyer les alertes de votre serveur Nagios sur un compte Twitter (ou comment réunir les SI et le Web 2.0). Malheureusement, depuis cette date,  Twitter a changé la méthode d’authentification pour poster des tweets. Ce n’est plus une authentification HTTP classique (qui pouvait donc être facilement faite en ligne de commande avec curl par exemple) mais une authentification oAuth, beaucoup plus souple mais nettement plus complexe.

Nous allons donc dans ce nouveau billet voir comment mettre en place l’authentification oAuth pour un script Python qui permettra à partir d’une simple ligne de commande de mettre à jour une timeline Twitter.

A vos fourneaux !

Les ingrédients…

Pour suivre cette recette il faut:

  • un compte Twitter
  • la librairie Python python-tweepy
  • un navigateur Web (pour enregistrer votre application)

Installation de Python-tweepy

Cette librairie Python va vous permettre de parler oAuth avec le serveur Twitter. Il existe un PPA pour Ubuntu (pour les autres distribution GNU/Linux, il faut installer la bête en suivant ces instructions):

sudo add-apt-repository ppa:chris-lea/python-tweepy

sudo aptitude update && sudo aptitude install python-tweepy

Update: Sous Debian la procédure à suivre est la suivante (merci Benjamin):

apt-get install python python-setuptools python-json python-twitter

wget http://pypi.python.org/packages/source/t/tweepy/tweepy-1.7.1.tar.gz

tar xvfz tweepy-1.7.1.tar.gz

cd tweepy-1.7.1

python ./setup.py install

Enregistrement de votre script

C’est la première étape: déclarer votre application (votre script) sur le serveur Twitter. Dans la suite de ce billet je vais procéder à l’enregistrement d’une application qui s’appellera ‘tweetit’ (c’est le nom de mon script en ligne de commande qui permettra de mettre à jour ma Timeline).

Pour cela, il faut se rendre à l’URL suivante: http://twitter.com/oauth_clients

Puis cliquer sur Register a new application »

On saisie ensuite le formulaire:

Une fois le formulaire validée, vous devriez être redirigé vers une page contenant deux informations importantes: Consumer key (la clés) et Consumer secret (le mot de passe) de votre application.

Il faut bien sur mettre ces informations de coté.

Connecter votre script à votre compte Twitter

Nous allons utiliser la librairie python-tweepy pour faire cette étape qui ne devra être faite qu’une seule fois lors du développement de votre application.

Le plus simple est de reprendre le script écrit par Jeff Miller sur son blog. On va donc créer un script nommé tweetit-register.py contenant le code suivant (remplacer les codes):

#!/usr/bin/env python

import tweepy

CONSUMER_KEY = ‘VOTRE CODE CONSUMER KEY’

CONSUMER_SECRET = ‘VOTRE CODE CONSUMER SECRET’

auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)

auth_url = auth.get_authorization_url()

print ‘Please authorize: ‘ + auth_url

verifier = raw_input(‘PIN: ‘).strip()

auth.get_access_token(verifier)

print « ACCESS_KEY = ‘%s' » % auth.access_token.key

print « ACCESS_SECRET = ‘%s' » % auth.access_token.secret

On exécute le script:

chmod a+x tweetit-register.py

./tweetit-register.py

Le script va vous afficher une URL  et attendre un code PIN:


Please authorize: http://twitter.com/oauth/authorize?oauth_token=Ndddb0DBsjd6PNYccSEtl8vtdYkNsPRCk5joO7djqO8

PIN:

On copie l’URL dans un navigateur Web:

On récupère ensuite le code PIN que l’on entre dans notre terminal:

PIN: 0665141

On obtient en retour la clés et le mot de passe d’accès :

ACCESS_KEY = ‘7707822-TWzha9rf3icVF1h0FhGnaK5q7iLyNIRzHXDY8aagt4’

ACCESS_SECRET = ‘3dbTcWkU1LIYG4MtwmraausjaoSne5coGbXKOXhDfG0’

Création du script

Voilà (enfin), on peut développer notre application (tweetit.py):

#!/usr/bin/env python


import sys

import tweepy


# Authentification oAuth

CONSUMER_KEY = ‘Consumer Key’

CONSUMER_SECRET = ‘Consumer Secret’

ACCESS_KEY = ‘Access Key’

ACCESS_SECRET = ‘Access Secret’

auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)

auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)

api = tweepy.API(auth)


# Main program

api.update_status(sys.argv[1])

On rend le script executable:

chmod a+x tweetit.py

Test de l’application

On lance le script avec le texte à tweeter:

./tweetitcli.py ‘Petit test depuis la ligne de commande Linux…’

Et voilà le travail:

Et voila, bientôt un prochain billet pour voir comment intégrer ce nouveau script à Nagios 🙂

Source pour la rédaction de cet article:

Catégories
Open-source Planet-libre Systeme

Transformer son iPhone en trackpad pour GNU/Linux

Apple vient de sortir son Magic Trackpad qui sera supporté nativement dans la prochaine version d’Ubuntu (la 10.10). Néanmoins, beaucoup d’entrenous disposons d’un dispositif de pointage multi-point performant dans notre poche: l’iPhone… Nous allons donc voir dans ce billet comment piloter notre système GNU/Linux (Ubuntu pour l’exemple mais la procédure doit pouvoir marcher sur d’autres distributions) depuis notre smartphone Apple !

Le logiciel en question permettant de réaliser ce « truc de geek » se nomme RemotePad à le bon goût d’être disponible sous Windows, Mac OS, BSD et Linux. Il utilise l’IP comme protocole de transport. Il faut donc que le PC à contrôler et l’iPhone (qui jouera la fonction de trackpad) soient connectés sur le même réseau local.

Le principe est relativement simple: il faut installer un serveur RemotePad (sous licence GPL v2) sur le PC à contrôler et l’application cliente RemotePad sur l’iPhone.

Installation du serveur sur le PC GNU/Linux

Le serveur doit être compilé à partir des sources, rien de compliqué, il suffit de saisir les commandes suivantes dans un terminal:

sudo aptitude install libxtst-dev

mkdir ~/src

cd ~/src

wget http://iphone-remotepad.googlecode.com/files/RemotePadServer-1.10-X11-Source.tgz

tar zxvf RemotePadServer-1.10-X11-Source.tgz

cd RemotePad\ Server/

cd X11

./configure

make

sudo make install

Lancement du serveur sur le PC GNU/Linux

Il suffit de lancer la commande suivante dans un terminal:

remotepad

Si tout ce passe bien, le message suivant devrait apparaître:

RemotePad Server for X11 version 1.10

Application launched.

enter 192.168.0.3 in your iPhone/iPod touch.

En gros, cela dit que le serveur est bien lancé et écoute sur l’adresse 192.168.0.3.

Installation de l’application sur l’Iphone

Rien de bien difficile:

Ensuite on lance le logiciel et on entre l’adresse IP fournie lors du démarrage du serveur:

Et voilà, votre Iphone joue maintenant le rôle d’un trackpad. Le serveur devrait afficher la ligne suivante:

Connected!

Et cela donne quoi ?

Je vous conseille d’aller dans les propriétés du client iPhone pour régler la vitesse du trackpad et la disposition des boutons. Après ces menu réglages, les premiers tests sont concluants même si, de temps en temps, il y a un léger « lag » surement due à mon réseau Wifi pas très performant. De plus je n’arrive pas à faire fonctionner le clavier.

Bref un exercice amusant mais pas forcement une solution de remplacement par rapport à un vrai trackpad !