Catégories
Open-source Planet-libre Reseau Web

Installation de Zimbra Collaboration Server 7

Zimbra est une suite collaborative regroupant des fonctions de messagerie (IMAP et POP), de gestion de vos contacts, de calendrier, de partage de documentations (voir la liste complète des fonctions ici). L’éditeur de cette suite à la très bonne idée de diffuser une version open-source de cette suite qui s’appelle Zimbra Collaboration Server Open-Source édition.

Benjamin Carion, de la société Absystech vient de me faire parvenir une documentation d’installation qui servira de complément au wiki officiel. Elle détaille une installation de la version 7 de la suite sur une distribution Ubuntu 10.04 LTS.

Cette documentation est disponible sous deux formats: PDF et MediaWiki. Il suffit de cliquer sur le format de votre choix pour lancer le téléchargement.

Si vous voyez des erreurs ou des compléments à apporter à cette procédure, n’hésitez pas à laisser un commentaire un peu plus bas.

Merci beaucoup à Benjamin pour le partage, c’est aussi cela la forme des logiciels libres.

Catégories
Nagios Open-source Planet-libre Reseau

Installation pas à pas d’un serveur de supervision Icinga

Icinga est un des nombreux forks libres de Nagios qui font pas mal parler d’eux en ce moment. Il apporte son lot d’amélioration par rapport « à son père » comme une architecture distribuée, une utilisation possible des bases de données MySQL/PgSQL/Oracle ou encore une interface Web tirant partie des dernières technologies dans le domaine (cliquez ici pour tester la démonstration de l’interface Web Icinga). Pour voir une comparaison pas forcément impartiale entre Icinga et Nagios, vous pouvez consulter ce tableau.

Dans ce billet, nous allons installer et configurer un serveur de supervision Icinga sur un serveur Debian (version Lenny ou supérieure mais la procédure doit être facilement adaptable à Ubuntu Server).

Les caractéristiques du serveur Icinga seront les suivantes:

  • Icinga dernière version disponible
  • Données de surperision stockées dans une base de donnée MySQL
  • Interface Web basée sur Apache
  • Plugins Nagios 1.4.15

Cette procédure a été testé sur une machine virtuelle (VM) sous Debian 6.0 Squeeze fraichement installée.

Préparation de l’installation

Nous allons installer Icinga depuis les sources se trouvant dans le dépôt Git officiel. Nous aurons ainsi la dernière version disponible. Pour cela, il est nécessaire d’installer certaines librairies et outils sur votre système.

Note: Les commandes de ce billet ont été saisies dans un terminal administrateur. Il est également possible d’utiliser la commande sudo <cmd> pour executer certaines taches en tant qu’administrateur ou su – -c « <cmd> ».

On installe les pré-requis (à adapter si vous utilisez Ubuntu Server en lieu et place de Debian):

ETAPE 1

apt-get install apache2 build-essential libgd2-xpm-dev libjpeg62 libjpeg62-dev libpng12-0 libpng12-dev mysql-server mysql-client libdbi0 libdbi0-dev libdbd-mysql snmp libsnmp-dev git

En cas d’erreur (par exemple paquet introuvable), il faudra faire une recherche dans les dépots et remplacer la librairie manquante par la nouvelle version.

On passe ensuite à la création du compte utilisateur et du groupe avec lesquels Icinga sera exécuté.  Je préfère personnellement utiliser le compte nagios (et le groupe nagios) plutôt que icinga comme on le trouve sur la documentation officielle. En effet, cela permet de simplifier une migration éventuelle d’un serveur Nagios vers Icinga.

ETAPE 2

groupadd nagios

useradd -g nagios -c « Nagios User » -s /bin/noshellneeded nagios

passwd nagios

usermod -a -G nagios www-data

Installation depuis les sources (Git)

On passe ensuite à la récupération de la dernière version de Icinga sur le gestionnaire de version Git officiel.

ETAPE 3

cd /usr/src

git clone git://git.icinga.org/icinga-core.git

cd /usr/src/icinga-core/

git submodule init

git submodule update

Puis on compile « la bête » avec les commandes suivantes:

ETAPE 4

./configure –with-icinga-user=nagios –with-icinga-group=nagios –with-nagios-user=nagios –with-nagios-group=nagios –with-command-user=nagios –with-command-group=nagios –prefix=/usr/local/icinga –enable-idoutils –enable-ssl

make all

make fullinstall

Si vous souhaitez protéger l’accès à l’interface Web d’Icinga avec un login/password, il faut également saisir la commande suivante. Par exemple pour définir un compte icingaadmin:

htpasswd -c /usr/local/icinga/etc/htpasswd.users icingaadmin

Installation des plugins Nagios

Comme Icinga est un fork de Nagios, il est possible d’utiliser directement les plugins de Nagios en version 1.4.15 au moment de la rédaction de ce billet.

Pour les installer on saisi:

ETAPE 5

cd /usr/src

wget http://downloads.sourceforge.net/project/nagiosplug/nagiosplug/1.4.15/nagios-plugins-1.4.15.tar.gz

tar zxvf nagios-plugins-1.4.15.tar.gz

cd nagios-plugins-1.4.15

./configure –prefix=/usr/local/icinga –with-cgiurl=/icinga/cgi-bin –with-htmurl=/icinga –with-nagios-user=nagios –with-nagios-group=nagios

make

make install

make install-root

Configuration de IDO

Arrivé à ce point de l’installation, vous devriez avoir un Icinga fonctionnel avec une base de donnée locale sous la forme de fichier texte (c’est le mode par défaut de Nagios). Pour avoir une installation évolutive et permettant d’exploiter les données issues de Nagios sur d’autres applications, il est nécessaire de configurer Icinga pour utiliser une base de donnée (MySQL dans notre exemple) en lieu et place de ces fichiers textes.

Pour cela, nous allons utiliser le module IDO qui fait l’interface entre Icinga et MySQL (ou PgSQL…). Ce module est l’équivalent du module NDO dans l’écosystème Nagios.

Le module IDO est installé par défaut suite à l’utilisation de l’option –enable-idoutils lors de la configuration de la compilation de Icinga. Il suffit donc de le configurer en suivant les indications suivantes:

ETAPE 6

cp /usr/local/icinga/etc/idomod.cfg-sample /usr/local/icinga/etc/idomod.cfg

sed -i -e « s/^use_ssl=0/use_ssl=1/g » /usr/local/icinga/etc/idomod.cfg

sed -i -e « s/^output_type=unixsocket/output_type=tcpsocket/g » /usr/local/icinga/etc/idomod.cfg

sed -i -e « s/^output=\/usr\/local\/icinga\/var\/ido.sock/output=127\.0\.0\.1/g » /usr/local/icinga/etc/idomod.cfg

cp /usr/local/icinga/etc/ido2db.cfg-sample /usr/local/icinga/etc/ido2db.cfg

sed -i -e « s/^use_ssl=0/use_ssl=1/g » /usr/local/icinga/etc/ido2db.cfg

sed -i -e « s/^socket_type=unix/socket_type=tcp/g » /usr/local/icinga/etc/ido2db.cfg

sed -i -e « s/^#broker_module=\/usr\/local\/icinga\/bin\/idomod.o\ config_file=\/usr\/local\/icinga\/etc\/idomod.cfg/broker_module=\/usr\/local\/icinga\/bin\/idomod.o\ config_file=\/usr\/local\/icinga\/etc\/idomod.cfg/g » /usr/local/icinga/etc/icinga.cfg

cat >> /usr/local/icinga/etc/modules/idoutils.cfg < EOF
define module{
module_name ido_mod
path /usr/local/icinga/bin/idomod.o
module_type neb
args config_file=/usr/local/icinga/etc/idomod.cfg
}
EOF

On doit enfin créer la base de donnée MySQL qui va stocker les données d’Icinga.

ETAPE 7

mysql -u root -p

mysql> CREATE DATABASE icinga; GRANT USAGE ON *.* TO ‘icinga’@’localhost’ IDENTIFIED BY ‘icinga’; GRANT SELECT , INSERT , UPDATE , DELETE ON icinga.* TO ‘icinga’@’localhost’;

mysql> FLUSH PRIVILEGES;

mysql> quit

mysql -u root -p icinga < /usr/src/icinga-core/module/idoutils/db/mysql/mysql.sql

Par défault, la base de donnée s’appelle icinga et elle sera accessible seulement en local (localhost) par l’utilisateur MySQL icinga avec le mot de passe icinga. (vous pouvez bien sur changer ces paramètres dans la base de donnée mais il faudra alors veiller à également les modifier dans le fichier ido2db.cfg).

Test de l’installation d’Icinga

On relance les processus pour prendre en compte notre configuration:

ETAPE 8

/etc/init.d/ido2db start

/etc/init.d/icinga start

/etc/init.d/apache2 restart

Puis on automatise le démarrage d’Icinga au prochain boot du serveur:

ETAPE 9

update-rc.d ido2db defaults

update-rc.d icinga defaults

Vous devriez avoir un Icinga fonctionnel ! Pour vérifier ceci, il suffit de pointer un navigateur Web vers l’URL suivante: http://<adresse ip serveur icinga>/icinga (ou http://localhost/icinga)

Migration de votre configuration Nagios (optionnel)

Comme nous l’avons vu au début de ce billet, Icinga est un fork de Nagios. C’est à dire qu’il est tout à fait possible d’utiliser les plugins et les configurations d’un serveur Nagios existant directement dans votre nouveau serveur Icinga.

Je vous conseille dans un premier temps d’archiver la configuration initiale de Icinga pour pouvoir revenir en arrière en cas de problème:

cp -R /usr/local/icinga/etc /usr/local/icinga/etc.default

Ensuite on copie la configuration depuis le répertoire de Nagios. Je pars sur l’hypothèse ou le serveur Nagios est installé sur la même machine que votre serveur Icinga. Si ce n’est pas le cas, il faudra transférer les fichiers depuis votre serveur Nagios.

cp -R /usr/local/nagios/etc/* /usr/local/icinga/etc/

On transforme ensuite la configuration pour l’adapter à Icinga:

mv /usr/local/icinga/etc/nagios.cfg /usr/local/icinga/etc/icinga.cfg

sed -i ‘s/nagios/icinga/g’ /usr/local/icinga/etc/icinga.cfg

sed -i ‘s/nagios/icinga/g’ /usr/local/icinga/etc/cgi.cfg

sed -i ‘s/nagios/icinga/g’ /usr/local/icinga/etc/resource.cfg

cp /usr/local/icinga/etc.default/htpasswd.users /usr/local/icinga/etc/

On devrait ainsi avoir une configuration mélangeant celle faite pour Icinga (notamment en ce qui concerne IDO) et votre ancienne configuration de Nagios.

On vérifie que la configuration ne comporte pas d’erreur:

/usr/local/icinga/bin/icinga -v /usr/local/icinga/etc/icinga.cfg

Si c’est le cas, il suffit de relancer Icinga pour prendre en compte cette configuration:

/etc/init.d/ido2db restart

/etc/init.d/icinga restart

/etc/init.d/apache2 restart

Vous pouvez faire fonctionner les deux services (Nagios & Icinga) en parallèle sans aucun problème. Cela peut être utile pour une phase de migration. Par contre il faut garder à l’esprit que vous aurez deux fois plus de requêtes vers vos serveurs…

Sources:

Catégories
Nagios Open-source Planet-libre Reseau Systeme

Shinken découvre votre réseau pour vous

Si vous avez mis en place un serveur de supervision sur votre réseau, vous devez savoir que cette phase est souvent longue, fastidieuse et source d’erreur de configuration. Heureusement, la dernière version (0.6) de Shinken (le fork compatible Nagios développé de main de maitre par Jean Gabes) intègre un mesure de découverte de votre réseau.

Nous allons dans ce billet détailler les étapes pour utiliser ce module. Nous partons sur l’hypothèse ou vous avez un serveur Shinken/Thruk opérationnel. Si ce n’est pas le cas, j’ai développé un petit script shell permettant de faire cette installation pour vous.

C’est quoi donc ce module ?

Shinken-discovery est un programme qui va scanner les machines de votre réseau puis en déduire les services à superviser pour ensuite générer les fichiers de configurations pour Shinken.

Installation

Le scan de votre réseau se base sur le bien connu programme nmap qui doit donc être présent sur votre système.

Sur Debian / Ubuntu:

sudo aptitude install nmap

Sur Fedora:

yum install nmap

Le reste des programmes est inclue dans la version 0.6 (et supérieure) de Shinken.

Configuration

Si vous avez bien suivi, il faut maintenant dire à Shinken quel est le ou les réseaux à scanner. Cette configuration permet non seulement de découvrir des machines sur votre réseau local mais également (sous réserve de règles de filtrages compatible dans vos firewalls/routeurs) sur des réseaux distants.

La liste des réseaux à scanner est à configurer dans le fichier /etc/shinken/resource.cfg dans la variable $NMAPTARGETS$ (en fin de fichier):

# sudo vi /etc/shinken/resource.cfg

$NMAPTARGETS$=192.168.0.0/24 blog.nicolargo.com

Dans l’exemple ci-dessus je vais donc scanner:

  • 192.168.0.0/24: les 254 adresses de mon réseau local
  • blog.nicolargo.com: un serveur sur Internet que je surveille de près

Lancement de la découverte

Il suffit de saisir la commande suivante:

sudo shinken-discovery -o /etc/shinken/objects/discovery -r nmap

Selon la taille de votre réseau, cette opération peut prendre plus ou moins de temps (« I’m launching nmap »).

Comme on peut s’en douter, la configuration sera générée dans le répertoire /etc/shinken/objects/discovery. Le principal avantage est que l’on ne pert pas la configuration existante.

Note

Pour partir sur une nouvelle configuration basée uniquement sur le module de découverte (c’est à dire juste après une installation propre de Shinken), vous pouvez suivre la procédure suivante (au cas ou la configuration initiale est archivé dans /tmp/shinken-backup.tgz):

tar zcvf /tmp/shinken-backup.tgz /etc/shinken

sudo rm -f /etc/shinken/objects/hosts/*

sudo rm -f /etc/shinken/objects/services/*

sudo rm -f /etc/shinken/hostgroups.cfg

sudo touch /etc/shinken/hostgroups.cfg

sudo rm -f /etc/shinken/servicegroups.cfg

sudo touch /etc/shinken/servicegroups.cfg

/Note

On doit ensuite fixer les droits des fichiers générés:

sudo chown -R shinken:shinken /etc/shinken/objects/discovery

Prise en compte de la nouvelle configuration

Il suffit ensuite de redémarrer Shinken pour voir votre réseau:

sudo /etc/init.d/shinken restart

Si vous aviez déjà une configuration existante, il y a de forte chance pour que Shinken vous affiche un message d’erreur lors de la vérification de vos fichiers. Le résultat de la commande de check se trouve dans le fichier /tmp/shinken_checkconfig_result.

Par exemple, le module de découverte peut générer une entrée pour un host existant. Il faut alors éditer et ou supprimer le host en question pour que la configuration soit valide.

Conclusion

Ce billet n’est qu’une courte introduction à ce module qui peut être paramétré de manière beaucoup plus fine lors de la transformation du scan vers une configuration Shinken. J’aurai l’occasion de revenir prochainement sur ce vaste sujet.

Catégories
Nagios Open-source Planet-libre Reseau Systeme

Mise à jour 0.4 du script d’installation de Shinken/Thruk

Aussi bien pour Shinken que pour les Thruk, les mises à jour s’enchaînent avec une fréquence importante ces derniers temps. Cela démontre un grand dynamisme sur ce projet !

J’ai donc adapté le script d’installation automatique du couple Shinken/Thruk en ajoutant pas mal de contrôle sur le bon déroulement des téléchargement ainsi qu’une adaptation pour aller chercher Thruk dans les archives si la version du script n’est plus téléchargeable dans le répertoire officiel.

La version 0.4 du script va installer:

  • Shinken 0.6
  • Thruk 1.0.2

La procédure pour installer ou mettre à jour votre serveur de supervision Shinken est toujours la même:

cd ~

rm -f shinkenautoinstall-debian.sh

wget http://svn.nicolargo.com/shinkenautoinstall/trunk/shinkenautoinstall-debian.sh

chmod a+x shinkenautoinstall-debian.sh

sudo ./shinkenautoinstall-debian.sh

Si tout se passe comme prévu, le script devrait afficher:

—————————————————-

Installation is finished

—————————————————-

Backup configuration file : /tmp/shinken-backup-20110513073545.tgz

Configuration file folder : /etc/shinken

Log file : /var/lib/shinken/nagios.log

Shinken startup script : /etc/init.d/shinken

Thruk startup script : /etc/init.d/thruk

Thruk web interface URL : http://sam:3000

Dans certain cas, notamment lors d’une mise à jour, il faut ensuite relancer Shinken:

sudo /etc/init.d/shinken restart

Pour remonter les éventuels bugs / nouvelles fonctions, merci d’utiliser le site officiel du script qui se trouve sur GitHub à l’adresse suivante: https://github.com/nicolargo/shinkenautoinstall.

Catégories
Nagios Open-source Planet-libre Reseau Systeme

Mise à jour du script d’installation de Shinken/Thruk

Shinken, le système libre de supervision système et réseau compatible avec les fichiers de configurations et les plugins Nagios vient de sortir en version 0.6.

Cette nouvelle version apporte un lot impressionnant de nouveautés. Celle qui me semble la plus notable et sur laquelle je reviendrai dans un prochain billet est la découverte automatique de votre réseau. Plus besoin de faire toutes sa configuration à la main ! En effet, le « discovery module » permet d’automatiser cette tache fastidieuse.

Dès sa sortie, j’ai modifié le script d’installation automatique pour qu’il prenne en compte cette nouvelle version 0.6 de Shinken. J’en ai également profité pour modifier la version de Thruk (l’interface Web) pour utiliser la version 0.94.4. Je rappelle que le script a été développé et testé sur un système Debian mais il doit également fonctionner sous Ubuntu moyennant quelques modifications (lignes arch_version et perl_version).

Récupération du script d’auto installation de Shinken/Thruk

Il suffit d’ouvrir un terminal puis de saisir les commandes suivantes:

cd ~

rm -f shinkenautoinstall-debian.sh

wget https://raw.github.com/nicolargo/shinkenautoinstall/master/shinkenautoinstall-debian.sh

chmod a+x shinkenautoinstall-debian.sh

Lancement du script d’auto installation de Shinken/Thruk

Là encore rien de compliqué:

sudo ./shinkenautoinstall-debian.sh

Le script devrait se dérouler tout seul. Il vous demandera juste à un moment donnée de saisir le mot de passe que vous voulez affecter à l’utilisateur Unix shinken.

A la fin de l’installation, le serveur Shinken et l’interface Web Thruk seront lancées automatiquement.

—————————————————-

Installation terminée

—————————————————-

Fichiers de configuration : /etc/shinken

Fichiers de logs : /var/lib/shinken/nagios.log

Script de lancement de Shinken : /etc/init.d/shinken

Script de lancement de Thruk : /etc/init.d/thruk

Interface d’administration : http://@IP:3000

Arrivé à ce stade, vous pouvez éditer la configuration de Shinken (contenue dans le répertoire /etc/shinken) et vous connecter à l’interface Web d’administration (http://@IP:3000 ou @IP est à remplacer par l’adresse IP de votre serveur de supervision).

En bonus

Vous pouvez également utiliser le script pour mettre à jour un système Shiken existant (si il a été installé depuis les sources ou avec mon script). Dans ce cas, le script va sauvegarder votre configuration existante (le contenu du dossier /etc/shinken) dans un fichier .tgz (le nom et l’emplacement du fichier sont données à la fin de la mise à jour).

Il sera ensuite possible de restaurer cette configuration à la main.

Encore plus de Shinken ?

Jean Gabes, le papa de Shinken donnera une conférence sur son fils jeudi 12 mai au salon Solution Linux (à 15h30). Venez nombreux, il annonce une « conf de fou » 🙂 (il va avoir une belle pression…)

Catégories
Open-source Planet-libre Reseau

Capturer et analyser un trafic réseau avec Wireshark

Dans la boîte à outil des administrateurs et architectes réseaux, les outils de captures viennent souvent en bout de chaîne, quand toutes les autres solutions pour résoudre un problème ont été essayées. En effet, la capture et l’analyse d’un trafic réseau peut s’avérer fastidieuse pour une personne non avertie et lourde à mettre en place pour un spécialiste.

Nous allons donc dans ce billet prendre quelques pistes qui vous, je l’espère, vous permettre de vous y retrouver.

C’est quoi une capture réseau ?

Une capture réseau est une photo à un instant t (ou sur une période de temps t0/t1) de ce qui transite sur un réseau informatique. Si l’on choisi bien le point de capture, on pourra sauvegarder l’ensemble d’un trafic intéressant pour ensuite l’analyser à tête reposée.

Une capture réseau pour quoi faire ?

Les principales applications d’une capture puis d’une analyse réseau sont:

  • identifier les flux consommateurs sur une liaison Internet, WAN ou locale
  • caractériser le trafic généré par une nouvelle application (par exemple avant un déploiement)
  • identifier les causes d’un problème de performance sur un réseau (tempête de broadcast, problème physique sur un équipement)

Cette liste est bien sûr loin d’être exhaustive…

Ou effectuer la capture réseau ?

C’est un des points critiques. Il faut effectivement se positionner à un endroit ou l’on va capturer l’ensemble du trafic « intéressant » par rapport à votre besoin sans pour autant sauver des gigaoctets d’informations.

Pour analyser les flux d’une liaison WAN, le plus simple est de faire la capture au plus proche de l’interface réseau de sortie vers cette liaison. Si cette liaison n’est pas une liaison Ethernet, alors il faudra se positionner en amont du routeur gérant cette liaison.

Pour analyser une nouvelle application, le plus simple est de capturer le trafic sur un des PC clients ou sur le serveur dans le cas d’une architecture client/serveur).

Sur un réseau LAN commuté, vous pouvez soit utiliser les fonctions de redondance de port au niveau d’un commutateur central, soit positionner un bon vieux HUB à un endroit stratégique de votre réseau.

Comment faire la capture réseau ?

Pour prendre un exemple simple, nous allons capturer le trafic transitant par un routeur GNU/Linux (ou BSD). Ce dernier dispose de deux interfaces réseaux. La première coté LAN (eth0) , la seconde coté WAN (eth1). On commence dans un premier temps par installer Wireshark sur son routeur:

Exemple d’installation sous Ubuntu 10.04 LTS

sudo aptitude install wireshark

Si le routeur ne dispose pas d’interface graphique, nous utiliserons tshark. Ce logiciel permet de capturer le trafic puis de générer un fichier qui sera exploitable par WireShark sur une autre machine disposant d’une interface graphique.

Exemple d’installation sous Ubuntu 10.04 LTS

sudo aptitude install tshark

Ensuite on lance la capture avec Wireshark sur l’interface WAN (eth1):

On peut ensuite sauvegarder la capture faite par Wireshark en allant dans le menu File > Save. Attention, Wireshark est lancé par défaut avec le compte root, il faut donc faire cette sauvegarde dans un répertoire accessible par votre utilisateur standard (par exemple dans /tmp/capture.pcap).

Ou avec TShark sur l’interface WAN (eth1) en sauvegardant la capture dans le fichier /tmp/capture.pcap:

Commencer la capture:

sudo tshark -i eth1 -w /tmp/capture.pcap

Arrêter la capture:

CTRL+C

Comment analyser la capture réseau ?

Il faut un PC sur lequel Wireshark est installé (soit directement sur votre point de capture soit sur un autre PC sur lequel vous aurez téléchargé la capture). On peut noter que Wireshark est disponible sous GNU/Linux, BSD, Mac OS X et Windows. On commence par charger la capture par le menu File > Open (/tmp/capture.pcap). Une fois le fichier chargé, on peut voir que la fenêtre de Wireshark est, par défaut, divisée en 3 sections:

  • la première affiche une liste des paquets IP capturés
  • la seconde donne le détail du paquet IP sélectionné dans la première section
  • la troisième affiche le contenu (en hexadécimal) du paquet IP sélectionné dans la première section

Selon votre capture, il peut être utile d’appliquer un filtre qui ne va afficher que certains paquets. Il est également possible d’effectuer ce filtrage lors de la capture mais par expérience, j’évite de faire cela car on peut louper pas mal de choses…

Donc pour mettre en place un filtrage (par exemple pour n’afficher que les paquet dont l’adresse source est 192.168.200.21) il faut saisir le filtre dans la section Filter puis cliquer sur le bouton Apply:

Remarque: si le fond de la zone de saisie du filtre n’est pas verte, c’est qu’il y a une erreur de syntaxe.

La liste exhaustive des filtres d’affichage disponible est disponible sur cette page. Pour un filtrage au niveau IP on peut se contenter de cette page là.

Il est bien sûr possible de faire des filtre un peu plus complexe, par exemple:

(ip.src == 192.168.200.21) && (ip.dsfield.dscp == 46) && (ip.dst != 192.168.200.10)

Ce filtre va seulement afficher les paquets IP avec comme adresse IP source 192.168.200.21, tagué avec un champs DSCP à EF (valeur décimale = 46) et qui n’ont pas comme adresse de destination 192.168.200.10.

Un exemple concret de A à Z

Pour illustrer de manière plus concrète l’utilisation de ces filtres, nous allons capturer puis analyser la récupération d’une page Web sur mon blog à partir d’un poste client.

  1. On commence donc par lancer le navigateur sur le poste client.
  2. On lance ensuite Wireshark sur le poste client.
  3. On commence la capture sur l’interface eth0 du poste client.
  4. On surfe sur la page en question à partir d’un navigateur Internet. On attend que la page soit complètement chargée.
  5. On arrête la capture.

On devrait ainsi se retrouver avec une capture bien (trop ?) fournie. En effet, nos machines modernes font pas mal de choses en tache de fond. Certaine de ces actions génèrent des requêtes sur le réseau (vérification de présence de mise à jour système, mise à jour de votre Dropbox, requêtes réseau sur votre LAN…).

Nous allons donc commencer par filtrer le trafic intéressant qui, je le rappelle, est la récupération d’une page Web par votre navigateur. L’idée est de bâtir le filtre petit à petit en écartant les requêtes inutiles et en gardant celle nécessaire au bon chargement de la page.

On commence par filtrer les paquets dont l’adresse source ou destination est votre propre poste client (dans mon cas, l’adresse IP de ce client était 192.168.29.79). Pour obtenir la votre, il suffit d’utiliser la commande ifconfig.

Le premier paquets de notre flux devrait, en toute logique être une résolution DNS du domaine blog.nicolargo.com (mon blog sur lequel je charge la page). On voit bien que cette requête à bien été capturé mais avec elle du trafic inutile avant…

Le paquet en question porte le numéro 27, nous allons donc modifier légèrement le filtre pour n’afficher que les paquets dont le numéro est > à 26.

Comme vous allez le voir si vous faite le test, il reste un nombre très important de requêtes pour le simple chargement de cette page. Pour y voir un peu plus clair, il est également possible d’activer la résolution des noms de machines lors de l’affichage. Pour cela il faut se rendre dans le menu Edit > Preferences…

Pour voir la liste complète des requêtes client / serveur, nous pouvons utiliser la fonction conversation (menu Statistics > Conversations) de Wireshark qui va afficher la liste suivante:

On peut également utiliser les outils d’analyses spécifiques aux paquets HTTP en allant dans le menu Statistics > HTTP > Request…

On voit bien que le chargement d’une seule page implique un nombre très important de requêtes HTTP (TCP) sur le réseau et donc que l’optimisation et la limitation de ces requêtes aura un impact significatif sur le temps de chargement de vos pages.

Et si votre patron veut des graphes ?

Le chef, il aime bien les graphes, c’est plus simple à insérer dans un PowerPoint. Heureusement il existe une fonction permettant par exemple d’afficher des graphes  en appliquant le même genre de filtres que l’on a vu dans le chapitre précédant.

Pour cela il faut se rendre dans le  menu Statistics > IO Graphs.

Par défaut, c’est le filtre d’affichage actuel qui sera afficher avec la couleur noire correspondant au graphe n°1. L’échelle enordonnée est en nombre de paquets / seconde.

Pour passer en bits / seconde, il faut aller dans le menu Y Axis > Unit > Bits/Tick:

Pour ajouter d’autres courbes avec des filtres spécifiques, il suffit de saisir les champs Filter puis de cliquer sur le n° de graphes correspondant:

Il est bien sûr possible d’exporter les graphes dans un format facilement intégrable dans un rapport (BMP, JPG, PNG…) en cliquant sur le bouton « Enregistrer« .

Conclusion

Ce billet n’est qu’une simple introduction à l’analyse réseau qui est un sujet qui nécessite de bonnes  connaissances sur les réseaux IP. N’hésitez pas à utiliser les commentaires suivants si vous avez des questions complémentaire sur le sujet !

Catégories
Blog Open-source Planet-libre Reseau Systeme Web

Varnish n’a pas peur de la montée en charge

Ce matin, un tweet de Philippe Scoffoni m’a permis de re-découvrir le site Load Impact qui permet de tester la montée en charge de votre service Web en simulant un nombre croissant de connexion. J’ai profité de cet outil sympa pour tester les performances de mon blog sans et avec le proxy cache Varnish (dont j’avais détaillé l’installation dans ce billet).

Avant de commencer la comparaison, un détail de ma configuration serveur:

  • Hébergeur Gandi
  • OS Ubuntu 10.04 LTS
  • CPU 1 coeur avec 1 Go de RAM

Perfos sans Varnish

Le test est alors effectué dans l’architecture suivante:

On obtient ces résultats:

Sans grande surprise on voit que les performances s’écroulent quand le nombre de lecteurs simultanés augmente. Pour 50 lecteurs simultanés sur le Blog (ce qui est quand même un pic que je ne vois pas tous les jours :)), on a un temps de chargement de la page qui passe à plus de 25 secondes (alors qu’il est de moins d’une seconde quand il y a un seul lecteur).

Perfos avec Varnish

En ajoutant Varnish en front-end à Apache, on a l’architecture suivante:

Et les résultats…

… sont à la hauteur des attentes de Varnish !

En effet pour 50 lecteurs consultant le blog en simultané, le temps de chargement ne dépasse pas les 2 secondes. Pas mal pour un logiciel qui ne prend que 1 Go d’espace disque…

Alors vous attendez quoi pour passer à Varnish ?

Catégories
Nagios Open-source Planet-libre Reseau

Script d’installation automatique de Shinken/Thruk

Dans le petit monde des systèmes de supervision système et réseau, un nouveau venu pointe le bout de sa… lame: Shinken.

Développé de main de maître par Jean Gabes (un des spécialiste Français de Nagios), il en reprend la structure au niveau des fichiers de configuration tout en apportant de plus grandes des performances, le tout distribué sous une licence libre AGPL v3. Basée sur le langage Python, il offre une liste pour le moins  impressionnante de fonctions que vous pouvez consultez sur cette page.

Nous allons dans ce premier billet sur le sujet, détailler un script d’installation automatique du couple Shinken + Thruk (interface Web) sur une distribution GNU/Linux Debian (le script doit également fonctionner sur une distribution Ubuntu moyennant, peut être, quelques modifications, notamment l’édition des lignes arch_version et perl_version).

La version actuelle du script, va installer Shinken version 1.0 (à noter que cette version inclue une UI maison) et Thruk 1.1.7. Pour information, ces deux versions peuvent être utilisées dans un environnement de production.

Récupération du script d’auto installation de Shinken/Thruk

Il suffit d’ouvrir un terminal puis de saisir les commandes suivantes:

cd ~

rm -f shinkenautoinstall-debian.sh

wget –no-check-certificate https://raw.github.com/nicolargo/shinkenautoinstall/master/shinkenautoinstall-debian.sh

chmod a+x shinkenautoinstall-debian.sh

Vous pouvez également récupérer le script / remonter des demandes de nouvelles fonctions ou des bugs sur GitHub.

Lancement du script d’auto installation de Shinken/Thruk

Là encore rien de compliqué:

sudo ./shinkenautoinstall-debian.sh

Le script devrait se dérouler tout seul. Il vous demandera juste à un moment donnée de saisir le mot de passe que vous voulez affecter à l’utilisateur Unix shinken.

A la fin de l’installation, le serveur Shinken et l’interface Web Thruk seront lancées automatiquement.

—————————————————-

Installation terminée

—————————————————-

Fichiers de configuration : /etc/shinken

Fichiers de logs : /var/lib/shinken/nagios.log

Script de lancement de Shinken : /etc/init.d/shinken

Script de lancement de Thruk : /etc/init.d/thruk

Interface d’administration : http://@IP:3000

Arrivé à ce stade, vous pouvez éditer la configuration de Shinken (contenue dans le répertoire /etc/shinken) et vous connecter à l’interface Web d’administration (http://@IP:3000 ou @IP est à remplacer par l’adresse IP de votre serveur de supervision).

Petite astuce complémentaire pour les utilisateurs voulant faire transiter les connections vers l’interface d’administration Web par un serveur Web Nginx. Il suffit d’ajouter la configuration suivante dans un fichier de conf Nginx:

server {

listen 80;

server_name nagios.mondomaine.com;

location / {

proxy_pass http://127.0.0.1:3000;

proxy_redirect off;

proxy_set_header Host $host;

proxy_set_header X-Real-IP $remote_addr;

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

}

}

Toute les requêtes entrantes sur le port TCP 80 et le nom de machine  nagios.mondomaine.com (à adapter à votre serveur) seront redirigées vers Nagios (http://127.0.0.1:3000). Cela permet d’éviter d’avoir à ouvrir un port supplémentaire (le 3000) sur votre serveur…

Que fait exactement le script d’auto installation de Shinken/Thruk ?

Pas grand chose, mis à part:

  • installation des pré-requis système
  • création de l’utilisateur shinken et du groupe associé
  • téléchargement des sources de Shinken et de Thruk
  • mise en place des scripts de démarrage de Shinken et Thruk (init.d)
  • vérification de la configuration de Shinken (l’équivalent de l’option -v de Nagios)
  • premier lancement de Shinken
  • premier lancement de Thruk

Si vous testez ce script sur Debian ou sur une autre distribution, je suis preneur de vos retours.

Sources:

Catégories
Nagios Open-source Planet-libre Reseau Systeme

Et un eBook gratuit sur Nagios, un…

On m’a plusieurs fois proposé d’écrire un livre sur Nagios et la supervision système et réseau. J’ai, pour l’instant, refusé ces offres par manque de temps et de motivation. Le Blog de Nicolargo m’occupe déjà  beaucoup et je trouve cette formule plus « interactive » que le support papier.

Cependant, je sais par expérience qu’il est parfois utile d’avoir une documentation papier ou sous la forme d’un simple fichier sur une clés USB. C’est donc pour cette raison que j’ai compilé l’ensemble des billets de ce blog abordant Nagios dans un eBook au format PDF sous licence Creative Common BY NC.

Pour télécharger gratuitement cet eBook, il suffit de cliquer sur l’image suivante:

Je vous rappelle, que l’ensemble des billets sur Nagios est regroupé également sur cette page (vous trouverez encore plus d’informations que dans l’eBook). Si vous voulez être tenu au courant des nouveaux articles, je vous conseille de vous abonner au flux RSS du blog, à mon compte Twitter ou à partir de Facebook.

Bonne lecture !

Catégories
Open-source Reseau

IperfiT, un petit script pour les fans de Iperf

J’utilise actuellement Iperf (voir la liste des billets sur le sujet ici) dans le cadre de tests de performances de réseaux divers et variés. Bien que très simple à utiliser pour une personne avertie, Iperf n’est pas conçu pour automatiser des benchs en faisant varier les cibles et les paramètres.

J’ai donc développé, sous licence LGPL, un script Perl nommé IperfiT qui fait « grosso modo » les choses suivantes lors d’un test entre les machines A (sur lequel le script sera lancé) et B (qui se trouve de l’autre coté du réseau à tester et qui accepte les connexions SSH venant de A):

  • Test de la connectivité avec la machine B (A ping B)
  • Connexion automatiquement en SSH vers la machine B
  • Lancement du serveur IPerf sur la machine B
  • Lancement du client sur la machine A
  • Affichage du rapport venant de l’IPerf de la machine B
  • Arrêt de l’Iperf de la machine B

Les options de la version 0.1 de IperfiT sont les suivantes:

-h: Print the command line help

-v: Print the program version

-q: Quiet mode (no display)

-s <ip>: Server IP address

-n <user>: SSH user name used to connect to the server

-u: Use UDP protocol (default is TCP)

-b: Target bitrate for UDP flow

-t <time>: Test duration, default is 30 sec

-m <mss>: Set the TCP Maximum Segment Size (MTU-40), default 1400 bytes

-w <wsize>: Set the TCP Window Size, default 128 Kbytes

-l <bsize>: Set the R/W Buffer Size, default 8000 bytes

-d <tos>: Set the TOS field (Diffserv), default is 0

Installation de IperfiT

C’est assez simple, je l’ai mis à disposition dans ce répertoire. Vous pouvez également suivre cette procédure:

cd /tmp

wget https://raw.githubusercontent.com/nicolargo/iperfit/master/iperfit.pl

chmod a+rx /tmp/iperfit.pl

cp /tmp/iperfit.pl /usr/local/bin

Utilisation de iperfiT en quelques exemples

Pour un simple test TCP de 5 minutes (300 secondes) vers la machine 192.168.0.100 (login SSH nicolargo) avec une taille MSS de 1200 octets:

iperfit.pl -c 192.168.0.100 -n nicolargo -t 300 -m 1200

Pour lancer un test entre votre machine et la machine d’adresse IP 192.168.0.100 (login SSH nicolargo) en UDP avec une taille de buffer de 170 octets sur une durée de 60 secondes et avec un débit de 64 Kbps, il suffit de saisir la ligne suivante:

iperfit.pl -c 192.168.0.100 -n nicolargo -u -l 170 -t 60 -b 64

Remarque

Si vous avez le message suivant au lancement du programme:

Can’t locate Net/IPv4Addr.pm in @INC (@INC contains: /etc/perl /usr/local/lib/perl/5.10.1 /usr/local/share/perl/5.10.1 /usr/lib/perl5 /usr/share/perl5 /usr/lib/perl/5.10 /usr/share/perl/5.10 /usr/local/lib/site_perl .) at ./iperfit.pl line 33.BEGIN failed–compilation aborted at ./iperfit.pl line 33.

C’est que vous n’avez pas la librairie Perl IPv4Addr qui est installé, sous Ubuntu/Debian pour remédier à cela il faut saisir la commande suivante:

sudo aptitude install libnetwork-ipv4addr-perl

Si vous avez des améliorations à proposer à ce script je suis à votre écoute !