Conception d'un équivalent léger à Munin/Cacti

[moomba]

Bonjour,

Un petite intro, puis ensuite le vif du sujet :

J'ai quelques machines que je souhaite monitorer. Cela comprend :

2 PC standarts

1 Serveur

1 Raspberry

1 Arduino Uno (pour la température du plus gros des PC)

Je souhaite avoir, quand c'est possible, le maximum d'infos : %CPU, Ram, Swap, I/O disque, Traffic Net, Température, etc

Objectif : quelque chose le plus simple possible, avec le moins de dépendances possibles, facile a mettre en route, et compatible avec toutes les architectures.

Je me suis donc bricolé un truc en bash, sous forme d'un "deamon" qui sonde les machines tous les X minutes par ssh, et d'un script de rendu, que j'execute et qui me rend les infos sous forme HTML avec des graphs, etc.

Dépendances : bash, quelques gnu utils (awk, sed, etc), et gnuplot pour les rendus. Notez que gnuplot intégre son propre moteur de rendu, et peut donc être compilé simplement, sans avoir besoin de cairo.

Je souhaite votre avis sur ce script. On commence par le daemon. Qu'en pensez vous ? Il y a t-il des choses abérantes/instables/deprecated ? (notez que Gorky est le nom du PC, qui se sonde lui même)

Notez aussi que le premier paquet d'instructions correspond à un échantillonage locale, alors que le second correspond à un échantillonage sur un pc distand par ssh.

Main.bash

#!/bin/bash## VARIABLES## GorkyGorky_previous_date="0"Gorky_previous_totalip_in="0"Gorky_previous_totalip_out="0"Gorky_repertory_name="Gorky"# MyServerMyServer_previous_date="0"MyServer_previous_totalip_in="0"MyServer_previous_totalip_out="0"MyServer_repertory_name="MyServer"MyServer_login="me"MyServer_ip="myserver.fr"## MAIN LOOP#while truedoecho "Check"	Out_buffer=$(./FullCheck.bash $Gorky_previous_date $Gorky_previous_totalip_in $Gorky_previous_totalip_out)	Gorky_previous_date=$( echo $Out_buffer | awk '{print $1;}')	Gorky_previous_totalip_in=$( echo $Out_buffer | awk '{print $2;}')	Gorky_previous_totalip_out=$( echo $Out_buffer | awk '{print $3;}')	echo $Out_buffer | awk 'match($0,"Next"){print substr($0,RSTART+5)}' >> "./$Gorky_repertory_name/Log.dat"	Out_buffer=$(ssh "$MyServer_login@$MyServer_ip" 'bash -s' < SSH_LLCheck.bash $MyServer_previous_date $MyServer_previous_totalip_in $MyServer_previous_totalip_out)	MyServer_previous_date=$( echo $Out_buffer | awk '{print $1;}')	MyServer_previous_totalip_in=$( echo $Out_buffer | awk '{print $2;}')	MyServer_previous_totalip_out=$( echo $Out_buffer | awk '{print $3;}')	echo $Out_buffer | awk 'match($0,"Next"){print substr($0,RSTART+5)}' >> "./$MyServer_repertory_name/Log.dat"echo "Check OK, Sleep"sleep 5mdone

Et les sous scripts d'échantillonage (FullCheck et SSHLLcheck) qui sont pour le moment identiques :

# /bin/bashIn_Buffer="$@"previous_date=$( echo $In_Buffer | awk '{print $1;}')previous_totalip_in=$( echo $In_Buffer | awk '{print $2;}')previous_totalip_out=$( echo $In_Buffer | awk '{print $3;}')current_date=$(date +"%s")ipv4_in=$( echo "`egrep -v bond\|lo\|face\|Inter /proc/net/dev | awk -F' ' '{print $2;}' | paste -sd+ | bc` * 8" | bc )ipv4_out=$( echo "`egrep -v bond\|lo\|face\|Inter /proc/net/dev | awk -F' ' '{print $10;}' | paste -sd+ | bc` * 8" | bc )ipv6_in=$( echo "`egrep Ip6InOctets /proc/net/snmp6 | awk -F' ' '{print $2;}'` * 8"  | bc )ipv6_out=$( echo "`egrep Ip6OutOctets /proc/net/snmp6 | awk -F' ' '{print $2;}'` * 8"  | bc )totalip_in=$( echo "$ipv4_in + $ipv6_in" | bc )totalip_out=$( echo "$ipv4_out + $ipv6_out" | bc )totalip_in=$( echo "$totalip_in*0.001" | bc ) # in Kilooctets (from Octets)totalip_out=$( echo "$totalip_out*0.001" | bc ) # in Kilooctets (from Octets)difftotalip_in=$( echo "scale=4;( $totalip_in - $previous_totalip_in ) / ( $current_date - $previous_date )" | bc) # in Ko/sdifftotalip_out=$( echo "scale=4;( $totalip_out - $previous_totalip_out ) / ( $current_date - $previous_date )" | bc) # in Ko/scpu_idle=$( echo "`top -b -n 5 | grep -i "Cpu(s)" | tr -d '%id,' | awk '{print $5;}' | awk 'NR==5'`");cpu_used=$( echo "100 - $cpu_idle" | bc )MemTotal=$( echo "`grep -i "MemTotal" /proc/meminfo | tr -d 'kB' | awk '{print $2;}'`")MemFree=$( echo "`grep -i "MemFree" /proc/meminfo | tr -d 'kB' | awk '{print $2;}'`")Cached=$( echo "`grep -i "Cached" /proc/meminfo | tr -d 'kB' | awk '{print $2;}' | awk 'NR==1'`")Buffers=$( echo "`grep -i "Buffers" /proc/meminfo | tr -d 'kB' | awk '{print $2;}'`")MemUsed=$( echo "$MemTotal - $MemFree - $Buffers - $Cached" | bc )MemCached=$( echo "$Buffers + $Cached" | bc )MemUsed=$( echo "$MemUsed*0.001" | bc ) # in MegaBytesMemCached=$( echo "$MemCached*0.001" | bc ) # in MegaBytesMemFree=$( echo "$MemFree*0.001" | bc ) # in MegaBytesSwapTotal=$( echo "`grep -i "SwapTotal" /proc/meminfo | tr -d 'kB' | awk '{print $2;}'`")SwapFree=$( echo "`grep -i "SwapFree" /proc/meminfo | tr -d 'kB' | awk '{print $2;}'`")SwapUsed=$( echo "$SwapTotal - $SwapFree" | bc )SwapUsed=$( echo "$SwapUsed*0.001" | bc ) # in MegaBytes# First echo, returned variablesecho "$current_date $totalip_in $totalip_out"# Middle echo, to cut the returned lineecho "Next"# Second echo, to be written in the Log Fileecho "$( date +%Y-%d-%m-%H:%M ) $cpu_used $difftotalip_in $difftotalip_out $MemUsed $MemCached $MemFree $SwapUsed"

Les données sont donc stockées dans des fichiers textes en ASCII. Ce n'est pas un problème, a moins d'avoir des centaines de data, les volumes sont faibles (et c'est plus facilement portable).

Pour vous donner une idée du rendu final, une fois qu'on lance le script de rendu (que je vous soumettrai une fois qu'il sera plus propre), on a en html des graphs :

Bon, c'est pas encore folichon, mais c'est déjà pas mal. Et surtout, les dépendances sont faibles ! Et c'est customisable à l'infini. Je peut par exemple sonder mon arduino avec un scrypt python très facilement, ce qui n'est pas toujours le cas avec des gros du milieu, comme Munin ou Cacti.

Notez le cool down du weekend sur le CPU

Voilà, la méthode est brutale, mais le but est que ce soit facile à comprendre. Je doccumenterai chaque command par la suite (les awk, etc) dans les fichiers scripts.

J'attend vos retours

[RaphAstronome]

Il est hébergé sur le Raspberry ?

Car si c'est le cas la première optimisation pour Munin est de mettre la génération des graphs (les images) dans la RAM (tmpfs ou autre) pour soulager les IO.

Tu peux aussi faire la génération de graphs à la demande mais j'ai jamais testé.

Les rrd part contre il est préférable de les mettre en stockage permanent pour en cas de coupure.

Les plugins sont simples à faire, moi je les fais en Ruby et ça fonctionne très bien, ça devrait être possible en n'importe quel langage.

Pour l'utiliser un faut munin sur l'ordi qui fait les graphs, et les munin-node sur ceux qui sont à grapher.

[moomba]

Oui, c'est le Pi qui vas s'en occuper. C'est le seul allumé 24/24, les autres démarrent par Wake On Lan à partir du Pi.

La génération des graphs se fait sur demande : j’exécute le script, et la page HTML se met à jours. C'est léger, et j'ai déjà utilisé gnuplot pour de gros fichiers, il s'en sort plutôt bien.

Le souci des rrd, c'est effectivement les I/O. J'ai choisi de les stocker en ram à cause de la carte SD ou des possibles clés usb/disque ssd, histoire d'éviter des écritures inutiles. Et pour le moment, comme tout est divisé par le temps, les valeurs valent 0 au premier échantillonnage après redémarrage, donc c'est acceptable.

Le vrai souci de Munin, c'est sa dépendance. Je m'explique : je travail sur 2 calculateurs (des gros trucs, plusieurs milliers de CPU), d'architectures différentes. Par souci de stabilité des machines, je ne laisse pas tourner de daemon dessus, c'est déjà assez difficile de filtrer les processus. De plus, peu de libs sont dispo dessus (orienté performances purs), et je souhaite quelque chose qui tourne sans droits bien évidement.

J'ai testé Munin, mais il me demandait pas mal de packages (des plugins Perl, des libs, etc), et surtout me réclamait des droits admins. Encore une fois, j'évite d'utiliser ces droits, surtout sur les calculateurs. On peut presque tout faire sans droits (compile, install dans le home, etc), et le système est resté figé depuis des mois.

Voilà, pas très clair, mais j'espère que tu verras mon souci avec Munin

La finalité du truc est de pouvoir monitorer tout type de machine (même des systèmes comme les gestionnaires de Jobs sur les calculateurs, ca marche avec ce script), sans jamais rien installer, et sans avoir de droits.