Archives pour janvier, 2013

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

Amavis : utilisation d’un RAM-disque

root@server:~# nano /etc/fstab
tmpfs /var/lib/amavis/db  tmpfs noatime,nodev,nosuid,uid=amavis,gid=amavis,mode=0750,size=64m 0 0
tmpfs /var/lib/amavis/tmp tmpfs noatime,nodev,nosuid,uid=amavis,gid=amavis,mode=0770,size=512m 0 0

Ant : génération d’un bundle OSGI avec bnd

Bnd : https://bndtools.ci.cloudbees.com/job/bnd.master/ws/biz.aQute.bnd/generated/

bhuisgen@muse:~/Projects/java/libirc$ cat build.xml
<target name="dist" depends="doc" description="create package">
   <!-- JAR package -->
   <mkdir dir="${dist.home}/bin/${ant.project.name}" />
   <copy todir="${dist.home}/bin/${ant.project.name}">
      <fileset dir="${build.home}" />
   </copy>
   <jar destfile="${dist.home}/${ant.project.name}-${build.version}-bin-${DSTAMP}.jar" basedir="${dist.home}/bin/" />

   <!-- OSGI bundle -->
   <replaceregexp file="myfile.bnd" match="Bundle-Version: (.*)" replace="Bundle-Version: ${build.version}" byline="true" />
   <taskdef resource="aQute/bnd/ant/taskdef.properties" classpath="${lib.home}/bnd-2.0.0.jar"/>
   <bnd classpath="${build.home}" files="myfile.bnd" output="${dist.home}/${ant.project.name}-${build.version}-bundle-${DSTAMP}.jar" />
</target>
bhuisgen@muse:~/Projects/java/libirc$ cat libirc.bnd
Bundle-Name: IRC Client Framework Bundle
Bundle-SymbolicName: fr.hbis.lib.irc
Bundle-Version: 0.2.0

Private-Package: fr.hbis.lib.irc.*

FreeBSD : portmaster et conflit de nom de package

===>  Installing for pkgconf-0.8.9

===>  pkgconf-0.8.9 conflicts with installed package(s):
      pkg-config-0.25_1

      They install files into the same place.
      Please remove them first with pkg_delete(1).
*** Error code 1
root@box15:~ # portmaster -o devel/pkgconf devel/pkg-config

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.

Debian : autoriser l’installation des librairies 32 bits

bhuisgen@wheezy:~# sudo dpkg --add-architecture i386
bhuisgen@wheezy:~# sudo apt-get install ia32-libs

IPv6 : tester un serveur DNS

http://www.v6edu.com/dnstest/

Linux : restriction des droits sur les points de montage

/dev/mapper/vg-root /         ext4  errors=remount-ro            0  1
/dev/md0            /boot     ext2  noatime,nodev,nosuid,noexec  0  2
/dev/mapper/vg-swap none      swap  sw                           0  0
/dev/mapper/vg-var  /var      ext4  noatime,nodev,nosuid         0  2
/dev/mapper/vg-log  /var/log  ext4  noatime,nodev,nosuid         0  2
/dev/mapper/vg-tmp  /tmp      ext4  noatime,nodev,nosuid,noexec  0  2
/dev/mapper/vg-home /home     ext4  noatime,nodev,nosuid,noexec  0  2
Haut de page