Archives pour la catégorie ‘Monitoring’

Zabbix : monitoring de Dovecot

Monitoring de l’authentification utilisateur et du nombre d’utilisateurs connectés :

UserParameter=dovecot.auth,doveadm auth -x service=imap -x rip=127.0.0.1 test@noreply.my.domain blablablaaa|grep "auth succeeded"|wc -l
UserParameter=dovecot.who,doveadm who 2>/dev/null|wc -l

Zabbix : monitoring de php-apc

Un petit billet sur le monitoring de PHP-APC avec Zabbix.

Scripts web

Deux scripts PHP sont à placer dans le répertoire de votre serveur Web :

root@www:/var/www# cat apc-stats_mem.php
<?php print(serialize(apc_sma_info())); ?>
root@www:/var/www# cat apc-stats.php
<?php print(serialize(apc_cache_info('',true))); ?>

Script de monitoring Zabbix

Au niveau du monitoring, un nouveau script PHP va se charger de récupérer les valeurs actuelles d’APC :

root@www:/etc/zabbix/scripts# cat apc.php
<?php
$url_stats = "http://localhost/apc-stats.php";
$url_memstats = "http://localhost/apc-stats_mem.php";

$results = file_get_contents($url_stats);
if ($results == "")
   exit(1);

$results = unserialize($results);
$num_hits = $results["num_hits"];
$num_misses = $results["num_misses"];
$hits_ratio = $num_hits / ($num_hits + $num_misses) * 100;
$entries = $results["num_entries"];

$results = file_get_contents($url_memstats);
if ($results == "")
   exit(1);

$results = unserialize($results);
$mem_used = $results["seg_size"] * $results["num_seg"] - $results["avail_mem"];
$mem_available = $results["avail_mem"];

echo("num_hits=$num_hits\n");
echo("num_misses=$num_misses\n");
echo("hits_ratio=$hits_ratio\n");
echo("entries=$entries\n");
echo("mem_used=$mem_used\n");
echo("mem_available=$mem_available\n");
?>

Configuration de l’agent Zabbix

Reste à modifier l’agent Zabbix en y insérant les nouveaux paramètres :

root@www:/etc/zabbix# nano zabbix_agentd.conf
UserParameter=apc.num_hits,/usr/bin/php /etc/zabbix/scripts/apc.php|grep num_hits|cut -d"=" -f2
UserParameter=apc.num_misses,/usr/bin/php /etc/zabbix/scripts/apc.php|grep num_misses|cut -d"=" -f2
UserParameter=apc.hits_ratio,/usr/bin/php /etc/zabbix/scripts/apc.php|grep hits_ratio|cut -d"=" -f2
UserParameter=apc.entries,/usr/bin/php /etc/zabbix/scripts/apc.php|grep entries|cut -d"=" -f2
UserParameter=apc.mem_used,/usr/bin/php /etc/zabbix/scripts/apc.php|grep mem_used|cut -d"=" -f2
UserParameter=apc.mem_available,/usr/bin/php /etc/zabbix/scripts/apc.php|grep mem_available|cut -d"=" -f2

Zabbix : monitoring des IRQ

UserParameter=devint[*],cat /proc/interrupts | grep '$1:' | sed 's/\s/\n/g' | egrep '^[0-9]{1,}$'| awk '{sum+=$1} END {print sum}'

OSSEC : limiter les envois mail selon le niveau d’alerte

   <global>
     <email_notification>yes</email_notification>
     <email_to>allalerts@mydomain.com</email_to>
     <smtp_server>mail.mydomain.com</smtp_server>
     <email_from>ossec@mydomain.com</email_from>
   </global>

   <alerts>
     <log_alert_level>1</log_alert_level>
     <email_alert_level>7</email_alert_level>
     <email_to>user@mydomain.lu</email_to>
   </alerts> 

Rsyslog : activer le log d’un hôte distant

root@lovejoy:~# mkdir /var/log/remote
root@lovejoy:~# nano /etc/rsyslog.conf
# provides UDP syslog reception
$ModLoad imudp
$UDPServerRun 514

# provides TCP syslog reception
$ModLoad imtcp
$InputTCPServerRun 514

# rules
if $fromhost-ip startswith '10.0.0.1' then /var/log/remote/host.log
& stop
root@lovejoy:~# /etc/init.d/rsyslog restart

Zabbix : mise en place du partitionnement MySQL

Dans le cas où vous monitorez un nombre important de serveurs et d’items avec Zabbix, le partitionnement des tables SQL est une solution viable afin d’optimiser les performances de votre serveur. Le principe est de scinder horizontalement chaque table en divisant l’ensemble des enregistrements en sous-ensembles plus légers, optimisant ainsi les traitements. Les partitions sont considérées en interne comme de nouvelles tables et bénéficient donc de leurs propres index. Lors des requêtes, MySQL consulte uniquement les partitions nécessaires (un EXPLAIN PARTITION d’une requête confirme ce point). Plusieurs types de partitionnement existent, le plus simple probablement à comprendre étant celui par plage (range).

Dans le cas d’une base de données Zabbix, le partitionnement par range s’effectue au niveau du champ clock des tables. Certaines tables sont à partitionner par jour (history) et d’autres par mois ( trends). Le gain direct consiste en une souplesse de suppression des données, limitées dans ce cas à la suppression des partitions les plus anciennes. Le processus de HouseKeeping de Zabbix, visant à nettoyer toutes les tables par un DELETE sur chaque item, n’est donc plus nécessaire. Gain associé : il est possible d’augmenter la période de rétention des trends.

Voici la procédure de partitionnement des tables Zabbix.

Modification des clés primaires

Le partitionnement par range nécessite certaines modifications au niveaux des clés de certaines tables :

ALTER TABLE `acknowledges` DROP PRIMARY KEY, ADD KEY `acknowledgedid` (`acknowledgeid`);
ALTER TABLE `alerts` DROP PRIMARY KEY, ADD KEY `alertid` (`alertid`);
ALTER TABLE `auditlog` DROP PRIMARY KEY, ADD KEY `auditid` (`auditid`);
ALTER TABLE `events` DROP PRIMARY KEY, ADD KEY `eventid` (`eventid`);
ALTER TABLE `service_alarms` DROP PRIMARY KEY, ADD KEY `servicealarmid` (`servicealarmid`);
ALTER TABLE `history_log` DROP PRIMARY KEY, ADD PRIMARY KEY (`itemid`,`id`,`clock`);
ALTER TABLE `history_log` DROP KEY `history_log_2`;
ALTER TABLE `history_text` DROP PRIMARY KEY, ADD PRIMARY KEY (`itemid`,`id`,`clock`);
ALTER TABLE `history_text` DROP KEY `history_text_2`;

Ajout des partitions sur les tables mensuelles

Les tables mensuelles sont :

  • acknowledges
  • alerts
  • auditlog
  • events
  • service_alarms
  • trends
  • trends_uint

Conservant 12 mois de données, il faut créer pour chaque table 12 partitions + 1 pour le mois suivant le temps de création. A chaque début de mois, une nouvelle partition sera à ajouter (pour le mois suivant) et la plus ancienne est à supprimer.

Sur chacune de ces tables, les partitions sont créées de cette façon (au 31/01/2013) :

ALTER TABLE `acknowledges` PARTITION BY RANGE(clock) (
   PARTITION p201201 VALUES LESS THAN (UNIX_TIMESTAMP("2012-02-01 00:00:00")),
   PARTITION p201202 VALUES LESS THAN (UNIX_TIMESTAMP("2012-03-01 00:00:00")),
   PARTITION p201203 VALUES LESS THAN (UNIX_TIMESTAMP("2012-04-01 00:00:00")),
   PARTITION p201204 VALUES LESS THAN (UNIX_TIMESTAMP("2012-05-01 00:00:00")),
   PARTITION p201205 VALUES LESS THAN (UNIX_TIMESTAMP("2012-06-01 00:00:00")),
   PARTITION p201206 VALUES LESS THAN (UNIX_TIMESTAMP("2012-07-01 00:00:00")),
   PARTITION p201207 VALUES LESS THAN (UNIX_TIMESTAMP("2012-08-01 00:00:00")),
   PARTITION p201208 VALUES LESS THAN (UNIX_TIMESTAMP("2012-09-01 00:00:00")),
   PARTITION p201209 VALUES LESS THAN (UNIX_TIMESTAMP("2012-10-01 00:00:00")),
   PARTITION p201210 VALUES LESS THAN (UNIX_TIMESTAMP("2012-11-01 00:00:00")),
   PARTITION p201211 VALUES LESS THAN (UNIX_TIMESTAMP("2012-12-01 00:00:00")),
   PARTITION p201212 VALUES LESS THAN (UNIX_TIMESTAMP("2013-01-01 00:00:00")),
   PARTITION p201301 VALUES LESS THAN (UNIX_TIMESTAMP("2013-02-01 00:00:00"))
);

Ajout des partitions sur les tables journalières

Les tables journalières sont :

  • history
  • history_log
  • history_str
  • history_text
  • history_uint

L’historique étant de 7 jours, chaque table nécessite 7 partitions + 1 pour le jour suivant le temps de création. Chaque jour, une nouvelle partition sera également à ajouter, la plus ancienne à supprimer.

Sur chacune de ces tables, les partitions sont créées de cette façon (au 31/01/2013) :

ALTER TABLE `history` PARTITION BY RANGE(clock) (
   PARTITION p20130124 VALUES LESS THAN (UNIX_TIMESTAMP("2013-01-25 00:00:00")),
   PARTITION p20130125 VALUES LESS THAN (UNIX_TIMESTAMP("2013-01-26 00:00:00")),
   PARTITION p20130126 VALUES LESS THAN (UNIX_TIMESTAMP("2013-01-27 00:00:00")),
   PARTITION p20130127 VALUES LESS THAN (UNIX_TIMESTAMP("2013-01-28 00:00:00")),
   PARTITION p20130128 VALUES LESS THAN (UNIX_TIMESTAMP("2013-01-29 00:00:00")),
   PARTITION p20130129 VALUES LESS THAN (UNIX_TIMESTAMP("2013-01-30 00:00:00")),
   PARTITION p20130130 VALUES LESS THAN (UNIX_TIMESTAMP("2013-01-31 00:00:00")),
   PARTITION p20130131 VALUES LESS THAN (UNIX_TIMESTAMP("2013-02-01 00:00:00"))
);

Automatisation de la rotation des partitions

La rotation des partitions peut être effectuée par des triggers SQL. Ceux-si seront alors appelés par script cron.

DELIMITER //

CREATE PROCEDURE `zabbix`.`cron_monthly` ()
BEGIN
	CALL zabbix.create_monthly_partition("acknowledges");
	CALL zabbix.create_monthly_partition("alerts");
	CALL zabbix.create_monthly_partition("auditlog");
	CALL zabbix.create_monthly_partition("events");
	CALL zabbix.create_monthly_partition("service_alarms");
	CALL zabbix.create_monthly_partition("trends");
	CALL zabbix.create_monthly_partition("trends_uint");
	CALL zabbix.drop_monthly_partition("acknowledges");
	CALL zabbix.drop_monthly_partition("alerts");
	CALL zabbix.drop_monthly_partition("auditlog");
	CALL zabbix.drop_monthly_partition("events");
	CALL zabbix.drop_monthly_partition("service_alarms");
	CALL zabbix.drop_monthly_partition("trends");
	CALL zabbix.drop_monthly_partition("trends_uint");
END //

CREATE PROCEDURE `zabbix`.`cron_daily` ()
BEGIN
	CALL zabbix.create_daily_partition("history");
	CALL zabbix.create_daily_partition("history_log");
	CALL zabbix.create_daily_partition("history_str");
	CALL zabbix.create_daily_partition("history_text");
	CALL zabbix.create_daily_partition("history_uint");
	CALL zabbix.drop_daily_partition("history");
	CALL zabbix.drop_daily_partition("history_log");
	CALL zabbix.drop_daily_partition("history_str");
	CALL zabbix.drop_daily_partition("history_text");
	CALL zabbix.drop_daily_partition("history_uint");
END //

CREATE PROCEDURE `zabbix`.`create_monthly_partition` (TABLENAME VARCHAR(64))
BEGIN
	DECLARE NEXTCLOCK TIMESTAMP;
	DECLARE PARTITIONNAME VARCHAR(16);
	DECLARE CLOCK INT;

	SET NEXTCLOCK = DATE_ADD(NOW(), INTERVAL 1 MONTH);
	SET PARTITIONNAME = DATE_FORMAT(NEXTCLOCK, 'p%Y%m');
	SET CLOCK = UNIX_TIMESTAMP(DATE_FORMAT(DATE_ADD(NEXTCLOCK, INTERVAL 1 MONTH), '%Y-%m-01 00:00:00'));
	CALL zabbix.create_partition(TABLENAME, PARTITIONNAME, CLOCK);
END //

CREATE PROCEDURE `zabbix`.`drop_monthly_partition` (TABLENAME VARCHAR(64))
BEGIN
	DECLARE OLDCLOCK TIMESTAMP;
	DECLARE PARTITIONNAME VARCHAR(16);
	DECLARE CLOCK INT;

    SET @maxdays = 365;
    SET @old = @maxdays+1;
	SET OLDCLOCK = DATE_SUB(NOW(), INTERVAL @old DAY);
	SET PARTITIONNAME = DATE_FORMAT(OLDCLOCK, 'p%Y%m');
	CALL zabbix.drop_partition(TABLENAME, PARTITIONNAME);
END //

CREATE PROCEDURE `zabbix`.`create_daily_partition` (TABLENAME VARCHAR(64))
BEGIN
	DECLARE NEXTCLOCK timestamp;
	DECLARE PARTITIONNAME VARCHAR(16);
	DECLARE CLOCK INT;

	SET NEXTCLOCK = DATE_ADD(NOW(), INTERVAL 1 DAY);
	SET PARTITIONNAME = DATE_FORMAT(NEXTCLOCK, 'p%Y%m%d');
	SET CLOCK = UNIX_TIMESTAMP(DATE_FORMAT(DATE_ADD(NEXTCLOCK, INTERVAL 1 DAY), '%Y-%m-%d 00:00:00'));
	CALL zabbix.create_partition(TABLENAME, PARTITIONNAME, CLOCK);
END //

CREATE PROCEDURE `zabbix`.`drop_daily_partition` (TABLENAME VARCHAR(64))
BEGIN
	DECLARE OLDCLOCK TIMESTAMP;
	DECLARE PARTITIONNAME VARCHAR(16);
	DECLARE CLOCK INT;

    SET @maxdays = 7;
    SET @old = @maxdays+1;
	SET OLDCLOCK = DATE_SUB(NOW(), INTERVAL @old DAY);
	SET PARTITIONNAME = DATE_FORMAT(OLDCLOCK, 'p%Y%m%d');
	CALL zabbix.drop_partition(TABLENAME, PARTITIONNAME);
END //

CREATE PROCEDURE `zabbix`.`create_partition` (TABLENAME VARCHAR(64), PARTITIONNAME VARCHAR(64), CLOCK INT)
BEGIN
	DECLARE RETROWS INT;
	SELECT COUNT(1) INTO RETROWS
		FROM `information_schema`.`partitions`
		WHERE `table_schema` = 'zabbix' AND `table_name` = TABLENAME AND `partition_name` = PARTITIONNAME;

	IF RETROWS = 0 THEN
		SELECT CONCAT("create_partition(", PARTITIONNAME, ",", CLOCK, ")") AS msg;
     	SET @sql = CONCAT('ALTER TABLE `zabbix`.`', TABLENAME, '`', ' ADD PARTITION (PARTITION ', PARTITIONNAME, ' VALUES LESS THAN (', CLOCK, '));');
		PREPARE STMT FROM @sql;
		EXECUTE STMT;
		DEALLOCATE PREPARE STMT;
	END IF;
END //

CREATE PROCEDURE `zabbix`.`drop_partition` (TABLENAME VARCHAR(64), PARTITIONNAME VARCHAR(64))
BEGIN
	DECLARE RETROWS INT;
	SELECT COUNT(1) INTO RETROWS
		FROM `information_schema`.`partitions`
		WHERE `table_schema` = 'zabbix' AND `table_name` = TABLENAME AND `partition_name` = PARTITIONNAME;

	IF RETROWS = 1 THEN
		SELECT CONCAT( "drop_partition(", TABLENAME, ",", PARTITIONNAME, ")" ) AS msg;
     	SET @sql = CONCAT( 'ALTER TABLE `zabbix`.`', TABLENAME, '`',' DROP PARTITION ', PARTITIONNAME, ';' );
		PREPARE STMT FROM @sql;
		EXECUTE STMT;
		DEALLOCATE PREPARE STMT;
	END IF;
END //

DELIMITER ;

Deux script à planifier en cron vont appeller ces triggers; le premier à chaque début de mois et le second chaque jour :

root@zabbix:~# crontab -l
0 1 1 * * /root/scripts/zabbix_monthly.sh
0 1 * * * /root/scripts/zabbix_daily.sh
root@zabbix:~# cat /root/scripts/zabbix_monthly.sh
#!/bin/sh

mysql -B -h localhost -u root -psecret zabbix -e "CALL cron_monthly();"
root@zabbix:~# cat /root/scripts/zabbix_daily.sh
#!/bin/sh

mysql -B -h localhost -u root -psecret zabbix -e "CALL cron_daily();"

Pour finaliser, le process HouseKeeper de Zabbix est à désactiver (option de configuration DisableHousekeeping).

Zabbix : configuration d’un item trapper

La mise en place d’un item trapper est nécessaire lorsque le temps d’obtention de l’information à monitorer est supérieur au timeout imposé au niveau de l’agent Zabbix (par défaut de 5 secondes). Avec un item trapper, l’agent ne se charge ni de récupérer, ni d’envoyer l’information au serveur : tout est déporté à un script externe.

En guise d’exemple, ce script récupère le décalage temporel d’un hôte par rapport à un serveur NTP externe :

root@host:/etc/zabbix/scripts# cat ntpdate_offset.sh
#!/bin/sh

ZABBIX_SENDER=/usr/local/bin/zabbix_sender
ZABBIX_CONF=/usr/local/etc/zabbix/zabbix_agentd.conf

VALUE=$(ntpdate -q fr.pool.ntp.org | grep 'adjust time server' | awk '{print $10}')
echo - ntpdate.offset $VALUE | $ZABBIX_SENDER -c $ZABBIX_CONF -i -

Son exécution est à planifier en cron selon la fréquence de monitoring souhaitée. Au niveau du serveur Zabbix, il reste à créer et activer l’item ntpdate.offset en sélectionnant le type trapper.

Zabbix : monitorer l’activité d’un disque

Pour monitorer l’activité disque avec Zabbix, il convient de créer deux éléments par disque :

  • le premier pour la lecture avec la clé vfs.dev.read
  • le second pour l’écriture avec la clé vfs.dev.write

Il faut spécifier 512 comme coefficient de multiplication étant donné que Linux utilise 512 octets par bloc secteur.

 

Voici un rendu graphique des données récupérées :

Remarque : depuis la version 1.8.6 de Zabbix, il est possible de monitorer un volume LVM. Par exemple, pour le LV /dev/mapper/vg-sql, la clé à utiliser serait : vfs.dev.read[vg/sql,sectors].

Zabbix : monitorer un serveur Postfix

Voici les différents éléments de configuration nécessaires à la supervision d’un serveur Postfix avec Zabbix.

En premier lieu, rajouter un élément dans le fichier de configuration de l’agent Zabbix /etc/zabbix/zabbix_agentd.conf pour reporter le nombre actuel de mails dans la file d’exécution :

UserParameter=postfix.mailq,mailq|grep -v "Mail queue is empty"|grep -c '^[0-9A-Z]'

Ne pas oublier de créer l’élément dans l’interface web de Zabbix et le graphique associé.

Pour monitorer les statistiques sur les messages traités par Postfix, il convient d’installer les programmes pflogsumm ainsi que logcheck. Le premier permet d’analyser le journal du serveur et produire un rapport détaillés sur les messages. logcheck apporte quant à lui la commande logtail qui va permettre d’accélérer le temps de parsing du fichier log en gardant un offset de position à chaque passe par pflogsumm.

L’analyse s’effectue par ce script qu’il conviendra de placer en cron selon l’intervalle de temps désiré. Le script se charge d’envoyer les  différentes valeurs au serveur Zabbix gràce à la commande zabbix_sender :

#!/bin/bash
PFLOGSUMM=/usr/bin/pflogsumm.pl
MAILLOG=/var/log/mail.log
LOGTAIL=/usr/sbin/logtail
DAT1=/tmp/zabbix-postfix-offset.dat
DAT2=$(mktemp)
ZABBIX_SENDER=/usr/bin/zabbix_sender
ZABBIX_CONF=/etc/zabbix/zabbix_agentd.conf
DEBUG=0

function zsend {
   key="postfix.`echo "$1" | tr ' -' '_' | tr '[A-Z]' '[a-z]' | tr -cd [a-z_]`"
   value=`grep -m 1 "$1" $DAT2 | awk '{print $1}'`

   [ ${DEBUG} -ne 0 ] && echo "Send key \"${key}\" with value \"${value}\"" >&2
   $ZABBIX_SENDER -c $ZABBIX_CONF -k "${key}" -o "${value}" 2>&1 >/dev/null
}

$LOGTAIL -f $MAILLOG -o $DAT1 | $PFLOGSUMM -h 0 -u 0 --bounce_detail=0 --deferral_detail=0 --reject_detail=0 --no_no_msg_size --smtpd --warning_detail=0 > $DAT2

zsend received
zsend delivered
zsend forwarded
zsend deferred
zsend bounced
zsend rejected
zsend held
zsend discarded
zsend "reject warnings"
zsend "bytes received"
zsend "bytes delivered"
zsend senders
zsend recipients

rm $DAT2

Template XML : [Téléchargement introuvable]

Source : http://www.zabbix.com/wiki/howto/monitor/mail/postfix/monitoringpostfix

Zabbix : monitoring Nginx / PHP-FPM / MySQL

Voici les scripts que j’utilise pour monitorer avec Zabbix des serveurs Nginx / MySQL / PHP-FPM. Je vous livre également une template contenant l’ensemble des items et triggers.

zabbix_agentd.conf :

UserParameter=nginx.active,/etc/zabbix/scripts/nginx.pl|cut -f1|cut -d" " -f2
UserParameter=nginx.requests,/etc/zabbix/scripts/nginx.pl|cut -f2|cut -d" " -f2
UserParameter=nginx.reading,/etc/zabbix/scripts/nginx.pl|cut -f3|cut -d" " -f2
UserParameter=nginx.writing,/etc/zabbix/scripts/nginx.pl|cut -f4|cut -d" " -f2
UserParameter=nginx.waiting,/etc/zabbix/scripts/nginx.pl|cut -f5|cut -d" " -f2
UserParameter=php.ping,/etc/zabbix/scripts/php-fpm_ping.pl
UserParameter=php.conn,/etc/zabbix/scripts/php-fpm_status.pl|cut -f1|cut -d" " -f3
UserParameter=php.idle,/etc/zabbix/scripts/php-fpm_status.pl|cut -f2|cut -d" " -f3
UserParameter=php.active,/etc/zabbix/scripts/php-fpm_status.pl|cut -f3|cut -d" " -f3
UserParameter=php.total,/etc/zabbix/scripts/php-fpm_status.pl|cut -f4|cut -d" " -f3
UserParameter=php.maxchildren,/etc/zabbix/scripts/php-fpm_status.pl|cut -f5|cut -d" " -f3
UserParameter=mysql.status[*],/etc/zabbix/scripts/mysql_status.pl $1

/etc/zabbix/scripts/nginx.pl :

#!/usr/bin/perl#
# Boris HUISGEN <bhuisgen@hbis.fr>

use LWP::UserAgent;

my $URL = "http://127.0.0.1/nginx_status";

#
# DO NOT MODIFY AFTER THIS LINE
#

my $ua = LWP::UserAgent->new(timeout => 15);
my $response = $ua->request(HTTP::Request->new('GET', $URL));

my $active =  0;
my $reading = 0;
my $writing = 0;
my $waiting = 0;
my $requests = 0;

foreach (split(/\n/, $response->content)) {
 $active = $1 if (/^Active connections:\s+(\d+)/);

 if (/^Reading:\s+(\d+).*Writing:\s+(\d+).*Waiting:\s+(\d+)/) {
 $reading = $1;
 $writing = $2;
 $waiting = $3;
 }

 $requests = $3 if (/^\s+(\d+)\s+(\d+)\s+(\d+)/);
}

print "Active: $active\tRequests: $requests\tReading: $reading\tWriting: $writing\tWaiting: $waiting\n";

php-fpm_ping.pl :

#!/usr/bin/perl
#
# Boris HUISGEN <bhuisgen@hbis.fr>

use LWP::UserAgent;

my $URL = "http://127.0.0.1/php5fpm-ping";

#
# DO NOT MODIFY AFTER THIS LINE
#

my $ua = LWP::UserAgent->new(timeout => 15);
my $response = $ua->request(HTTP::Request->new('GET', $URL));

if ($response->is_success) {
 print "1\n";
}
else {
 print "0\n";
}

php-fpm_status.pl :

#!/usr/bin/perl
#
# Boris HUISGEN <bhuisgen@hbis.fr>

use LWP::UserAgent;

my $URL = "http://127.0.0.1/php5fpm-status";

#
# DO NOT MODIFY AFTER THIS LINE
#

my $ua = LWP::UserAgent->new(timeout => 15);
my $response = $ua->request(HTTP::Request->new('GET', $URL));

my $conn = 0;
my $idle = 0;
my $active = 0;
my $total = 0;
my $maxchildren = 0;

foreach (split(/\n/, $response->content)) {
 $conn = $1 if (/^accepted conn:\s+(\d+)/);
 $idle = $1 if (/^idle processes:\s+(\d+)/);
 $active = $1 if (/^active processes:\s+(\d+)/);
 $total = $1 if (/^total processes:\s+(\d+)/);
 $maxchildren = $1 if (/^max children reached:\s+(\d+)/);
}

print "Accepted conn: $conn\tIdle proc: $idle\tActive proc: $active\tTotal proc: $total\tMax children: $maxchildren\n";

mysql_status.pl :

#!/usr/bin/perl
#
# Boris HUISGEN <bhuisgen@hbis.fr>

my($mysql)   = "/usr/bin/mysql";
my($user)    = "zabbix";
my($passwd)  = "abcdef123";
my($host)    = "localhost";

#
# DO NOT MODIFY AFTER THIS LINE
#

=head1 NAME

mysql_status.pl - show MySQL variable status

=head1 SYNOPSIS

 mysql_status.pl VARIABLE

 --help                      print this help message
 --version                   print version information

=head1 DESCRIPTION

This program shows the status of a MySQL variable.

=head1 AUTHOR

Boris HUISGEN <bhuisgen@hbis.fr>

=cut

use strict;
use warnings;

use Getopt::Long qw(:config auto_help auto_version);
use Pod::Usage;

$main::VERSION = "0.1-2012040501";

exit main();

sub show_variable {
 my ($variable) = $_[0];

 my ($cmd) = "$mysql -u $user -p$passwd -h $host --execute \"SHOW GLOBAL STATUS LIKE '$variable'\" --skip-column-name";
 my ($ret) =`$cmd 2> /dev/null`;
 exit(1) unless($ret);

 $ret =~ m/^$variable.[\s\t]*(.*)/;
 print "$1\n";
}

sub main {
 GetOptions ()
 or pod2usage(1);

 pod2usage (1) unless ($#ARGV == 0);

 my ($variable) = $ARGV[0];

 show_variable($variable);
}

# end of script

nginx.conf :

server {
 listen          127.0.0.1:80;
 listen          [::1]:80;
 server_name     localhost;
 root            /var/www/default/www/html;
 access_log      /var/www/default/www/logs/access.log;
 error_log       /var/www/default/www/logs/error.log;
 index           index.html;

 location /nginx_status {
 stub_status on;
 access_log off;
 allow 127.0.0.1;
 deny all;
 }

 location = /php5fpm-status {
 fastcgi_pass    unix:/var/run/php5-fpm.sock;
 fastcgi_index   index.php;
 fastcgi_param   SCRIPT_FILENAME  /var/www/default/www/html$fastcgi_script_name;
 include         fastcgi_params;
 }

 location = /php5fpm-ping {
 fastcgi_pass    unix:/var/run/php5-fpm.sock;
 fastcgi_index   index.php;
 fastcgi_param   SCRIPT_FILENAME  /var/www/default/www/html$fastcgi_script_name;
 include         fastcgi_params;
 }

php-fpm.conf :

pm.status_path = /php5fpm-status
ping.path = /php5fpm-ping
ping.path = /php5fpm-ping

Template Zabbix : [Téléchargement introuvable]

Haut de page