¿Le gustaría aprender cómo realizar una partición de base de datos Zabbix? En este tutorial, le mostraremos cómo particionar la base de datos MySQL de Zabbix en una computadora que ejecuta Ubuntu Linux.

• Versión de Zabbix: 4.0.5
• Linux: Ubuntu 18.04
• MySQL: Ver 14.14 Distrib 5.7.25

Nuestro tutorial considera una nueva instalación de Zabbix.

Lista de Hardware:

La siguiente sección presenta la lista de equipos utilizados para crear este tutorial de Zabbix.

Todas las piezas de hardware mencionadas anteriormente se pueden encontrar en el sitio web de Amazon.

Zabbix Playlist:

En esta página, ofrecemos acceso rápido a una lista de videos relacionados con la instalación de Zabbix.

No olvides suscribirte a nuestro canal de youtube llamado FKIT.

Tutoriales Relacionados con Zabbix:

En esta página, ofrecemos acceso rápido a una lista de tutoriales relacionados con la instalación de Zabbix.

Tutorial – Particionamiento De Base De Datos Zabbix

Utilice el siguiente comando para instalar el software requerido.

# apt-get update
# apt-get install perl libdbi-perl libdatetime-perl libdbd-mysql-perl

Necesitamos particionar las siguientes tablas de la base de datos de Zabbix:

• history
• history_log
• history_str
• history_text
• history_uint
• trends
• trends_uint

Su servidor Zabbix probablemente ya tenga información de monitoreo dentro de su base de datos.

Acceda a la consola MySQL y verifique la fecha de entrada más antigua de Zabbix para las 7 tablas enumeradas anteriormente:

# mysql -u root -p

use zabbix;
SELECT FROM_UNIXTIME(MIN(clock)) FROM `history`;
SELECT FROM_UNIXTIME(MIN(clock)) FROM `history_log`;
SELECT FROM_UNIXTIME(MIN(clock)) FROM `history_str`;
SELECT FROM_UNIXTIME(MIN(clock)) FROM `history_text`;
SELECT FROM_UNIXTIME(MIN(clock)) FROM `history_uint`;
SELECT FROM_UNIXTIME(MIN(clock)) FROM `trends`;
SELECT FROM_UNIXTIME(MIN(clock)) FROM `trends_uint`;

Para cada uno de estos comandos MySQL, la salida debería ser algo similar a esto:

+—————————————+
| FROM_UNIXTIME(MIN(clock)) |
+—————————————+
| 2019-03-22 17:48:07                       |
+—————————————+
1 row in set (0.00 sec)

¡Importante! Tome nota de la fecha mostrada para cada una de las tablas.

Ahora, particionemos cada una de las Tablas de Historial por fecha:

Primero, vamos a particionar la tabla de historial.

# mysql -u root -p
# use zabbix;

ALTER TABLE `history` PARTITION BY RANGE ( clock)
(PARTITION p2019_03_22 VALUES LESS THAN (UNIX_TIMESTAMP(«2019-03-23 00:00:00»)) ENGINE = InnoDB);

En nuestro ejemplo, un archivo llamado p2019_03_22 tendrá toda la información de MySQL antes del 2019-03-23.

Si su fecha objetivo es 2019-03-22, debe ingresar todo antes de 2019-03-23.

En segundo lugar, vamos a particionar la tabla history_log.

ALTER TABLE `history_log` PARTITION BY RANGE ( clock)
(PARTITION p2019_03_22 VALUES LESS THAN (UNIX_TIMESTAMP(«2019-03-23 00:00:00»)) ENGINE = InnoDB);

En tercer lugar, vamos a particionar la tabla history_str.

ALTER TABLE `history_str` PARTITION BY RANGE ( clock)
(PARTITION p2019_03_22 VALUES LESS THAN (UNIX_TIMESTAMP(«2019-03-23 00:00:00»)) ENGINE = InnoDB);

En cuarto lugar, vamos a particionar la tabla history_text.

ALTER TABLE `history_text` PARTITION BY RANGE ( clock)
(PARTITION p2019_03_22 VALUES LESS THAN (UNIX_TIMESTAMP(«2019-03-23 00:00:00»)) ENGINE = InnoDB);

En quinto lugar, vamos a particionar la tabla history_uint.

ALTER TABLE `history_uint` PARTITION BY RANGE ( clock)
(PARTITION p2019_03_22 VALUES LESS THAN (UNIX_TIMESTAMP(«2019-03-23 00:00:00»)) ENGINE = InnoDB);

Ahora, vamos a dividir cada una de las Tabla de Tendencias por mes:

Primero, vamos a dividir la tabla de Tendencias.

ALTER TABLE `trends` PARTITION BY RANGE ( clock)
(PARTITION p2019_03 VALUES LESS THAN (UNIX_TIMESTAMP(«2019-04-01 00:00:00»)) ENGINE = InnoDB);

En nuestro ejemplo, un archivo llamado p2019_03 tendrá toda la información de MySQL antes del 2019-04-01.

Si su fecha objetivo es 2019-03, debe ingresar todo antes del 2019-04-01.

Segundo, vamos a particionar la tabla trends_uint.

ALTER TABLE `trends_uint` PARTITION BY RANGE ( clock)
(PARTITION p2019_03 VALUES LESS THAN (UNIX_TIMESTAMP(«2019-04-01 00:00:00»)) ENGINE = InnoDB);

Las particiones de la base de datos de Zabbix fueron creadas con éxito.

Tutorial – Script de Particionamiento de Base de Datos Zabbix

Vamos a utilizar un script Perl para realizar las siguientes tareas:

Cree 10 días de partición de base de datos MySQL antes de tiempo para evitar que el servicio se detenga.

Elimine las particiones MySQL anteriores que ya no son necesarias.

# mkdir /downloads/zabbix_script
# cd /downloads/zabbix_script
# vi zabbix_partition_creator.pl

Aquí está el contenido de la secuencia de comandos zabbix_partition_creator.pl:

use strict;
use Data::Dumper;
use DBI;
use Sys::Syslog qw(:standard :macros);
use DateTime;
use POSIX qw(strftime);
openlog(«mysql_zbx_part», «ndelay,pid», LOG_LOCAL0);
my $db_schema = ‘zabbix’;
my $dsn = ‘DBI:mysql:’.$db_schema.’:mysql_socket=/var/run/mysqld/mysqld.sock’;
my $db_user_name = ‘zabbix’;
my $db_password = ‘kamisama123’;
my $tables = { ‘history’ => { ‘period’ => ‘day’, ‘keep_history’ => ’30’},
‘history_log’ => { ‘period’ => ‘day’, ‘keep_history’ => ’30’},
‘history_str’ => { ‘period’ => ‘day’, ‘keep_history’ => ’30’},
‘history_text’ => { ‘period’ => ‘day’, ‘keep_history’ => ’30’},
‘history_uint’ => { ‘period’ => ‘day’, ‘keep_history’ => ’30’},
‘trends’ => { ‘period’ => ‘month’, ‘keep_history’ => ‘2’},
‘trends_uint’ => { ‘period’ => ‘month’, ‘keep_history’ => ‘2’},
};
my $amount_partitions = 10;
my $curr_tz = ‘America/Sao_Paulo’;
my $part_tables;
my $dbh = DBI->connect($dsn, $db_user_name, $db_password, {‘ShowErrorStatement’ => 1});
my $sth = $dbh->prepare(qq{SELECT table_name, partition_name, lower(partition_method) as partition_method,
rtrim(ltrim(partition_expression)) as partition_expression,
partition_description, table_rows
FROM information_schema.partitions
WHERE partition_name IS NOT NULL AND table_schema = ?});
$sth->execute($db_schema);
while (my $row = $sth->fetchrow_hashref()) {
$part_tables->{$row->{‘table_name’}}->{$row->{‘partition_name’}} = $row;
}
$sth->finish();
foreach my $key (sort keys %{$tables}) {
unless (defined($part_tables->{$key})) {
syslog(LOG_ERR, ‘Partitioning for «‘.$key.'» is not found! The table might be not partitioned.’);
next;
}
create_next_partition($key, $part_tables->{$key}, $tables->{$key}->{‘period’});
remove_old_partitions($key, $part_tables->{$key}, $tables->{$key}->{‘period’}, $tables->{$key}->{‘keep_history’})
}
delete_old_data();
$dbh->disconnect();
sub create_next_partition {
my $table_name = shift;
my $table_part = shift;
my $period = shift;
for (my $curr_part = 0; $curr_part < $amount_partitions; $curr_part++) {
my $next_name = name_next_part($tables->{$table_name}->{‘period’}, $curr_part);
my $found = 0;
foreach my $partition (sort keys %{$table_part}) {
if ($next_name eq $partition) {
syslog(LOG_INFO, «Next partition for $table_name table has already been created. It is $next_name»);
$found = 1;
}
}
if ( $found == 0 ) {
syslog(LOG_INFO, «Creating a partition for $table_name table ($next_name)»);
my $query = ‘ALTER TABLE ‘.»$db_schema.$table_name».’ ADD PARTITION (PARTITION ‘.$next_name.
‘ VALUES less than (UNIX_TIMESTAMP(«‘.date_next_part($tables->{$table_name}->{‘period’}, $curr_part).'») div 1))’;
syslog(LOG_DEBUG, $query);
$dbh->do($query);
}
}
}
sub remove_old_partitions {
my $table_name = shift;
my $table_part = shift;
my $period = shift;
my $keep_history = shift;
my $curr_date = DateTime->now;
$curr_date->set_time_zone( $curr_tz );
if ( $period eq ‘day’ ) {
$curr_date->add(days => -$keep_history);
$curr_date->add(hours => -$curr_date->strftime(‘%H’));
$curr_date->add(minutes => -$curr_date->strftime(‘%M’));
$curr_date->add(seconds => -$curr_date->strftime(‘%S’));
}
elsif ( $period eq ‘week’ ) {
}
elsif ( $period eq ‘month’ ) {
$curr_date->add(months => -$keep_history);
$curr_date->add(days => -$curr_date->strftime(‘%d’)+1);
$curr_date->add(hours => -$curr_date->strftime(‘%H’));
$curr_date->add(minutes => -$curr_date->strftime(‘%M’));
$curr_date->add(seconds => -$curr_date->strftime(‘%S’));
}
foreach my $partition (sort keys %{$table_part}) {
if ($table_part->{$partition}->{‘partition_description’} <= $curr_date->epoch) {
syslog(LOG_INFO, «Removing old $partition partition from $table_name table»);
my $query = «ALTER TABLE $db_schema.$table_name DROP PARTITION $partition»;
syslog(LOG_DEBUG, $query);
$dbh->do($query);
}
}
}
sub name_next_part {
my $period = shift;
my $curr_part = shift;
my $name_template;
my $curr_date = DateTime->now;
$curr_date->set_time_zone( $curr_tz );
if ( $period eq ‘day’ ) {
my $curr_date = $curr_date->truncate( to => ‘day’ );
$curr_date->add(days => 1 + $curr_part);
$name_template = $curr_date->strftime(‘p%Y_%m_%d’);
}
elsif ($period eq ‘week’) {
my $curr_date = $curr_date->truncate( to => ‘week’ );
$curr_date->add(days => 7 * $curr_part);
$name_template = $curr_date->strftime(‘p%Y_%m_w%W’);
}
elsif ($period eq ‘month’) {
my $curr_date = $curr_date->truncate( to => ‘month’ );
$curr_date->add(months => 1 + $curr_part);
$name_template = $curr_date->strftime(‘p%Y_%m’);
}
return $name_template;
}
sub date_next_part {
my $period = shift;
my $curr_part = shift;
my $period_date;
my $curr_date = DateTime->now;
$curr_date->set_time_zone( $curr_tz );
if ( $period eq ‘day’ ) {
my $curr_date = $curr_date->truncate( to => ‘day’ );
$curr_date->add(days => 2 + $curr_part);
$period_date = $curr_date->strftime(‘%Y-%m-%d’);
}
elsif ($period eq ‘week’) {
my $curr_date = $curr_date->truncate( to => ‘week’ );
$curr_date->add(days => 7 * $curr_part + 1);
$period_date = $curr_date->strftime(‘%Y-%m-%d’);
}
elsif ($period eq ‘month’) {
my $curr_date = $curr_date->truncate( to => ‘month’ );
$curr_date->add(months => 2 + $curr_part);
$period_date = $curr_date->strftime(‘%Y-%m-%d’);
}
return $period_date;
}
sub delete_old_data {
$dbh->do(«DELETE FROM sessions WHERE lastaccess < UNIX_TIMESTAMP(NOW() – INTERVAL 1 MONTH)»);
$dbh->do(«TRUNCATE housekeeper»);
$dbh->do(«DELETE FROM auditlog_details WHERE NOT EXISTS (SELECT NULL FROM auditlog WHERE auditlog.auditid = auditlog_details.auditid)»);
}

Debe cambiar las siguientes partes de la secuencia de comandos para reflejar su entorno MySQL.

my $db_schema = ‘zabbix’;
my $dsn = ‘DBI:mysql:’.$db_schema.’:mysql_socket=/var/run/mysqld/mysqld.sock’;
my $db_user_name = ‘zabbix’;
my $db_password = ‘kamisama123’;
my $tables = { ‘history’ => { ‘period’ => ‘day’, ‘keep_history’ => ’30’},
‘history_log’ => { ‘period’ => ‘day’, ‘keep_history’ => ’30’},
‘history_str’ => { ‘period’ => ‘day’, ‘keep_history’ => ’30’},
‘history_text’ => { ‘period’ => ‘day’, ‘keep_history’ => ’30’},
‘history_uint’ => { ‘period’ => ‘day’, ‘keep_history’ => ’30’},
‘trends’ => { ‘period’ => ‘month’, ‘keep_history’ => ‘2’},
‘trends_uint’ => { ‘period’ => ‘month’, ‘keep_history’ => ‘2’},
};
my $amount_partitions = 10;
my $curr_tz = ‘America/Sao_Paulo’;

En nuestro ejemplo, estamos utilizando el nombre de usuario de zabbix MySQL y la contraseña kamisama123 MySQL.

En nuestro ejemplo, mantenemos 30 días de contenido de tablas de historial.

En nuestro ejemplo, mantenemos 2 meses de contenido de tablas de tendencias.

En nuestro ejemplo, establecemos la zona horaria de fecha América / Sao_Paulo.

Ahora, necesita ejecutar manualmente el script sin errores.

# cd /downloads/zabbix_script
# chmod 700 zabbix_partition_creator.pl
# ./zabbix_partition_creator.pl

Acceda a la consola MySQL y verifique que el sistema haya creado 10 días de partición de historial antes de tiempo.

# mysql -u root -p

use zabbix;
show create table history;

/*!50100 PARTITION BY RANGE ( clock)
(PARTITION p2019_03_22 VALUES LESS THAN (1553310000) ENGINE = InnoDB,
PARTITION p2019_03_23 VALUES LESS THAN (1553396400) ENGINE = InnoDB,
PARTITION p2019_03_24 VALUES LESS THAN (1553482800) ENGINE = InnoDB,
PARTITION p2019_03_25 VALUES LESS THAN (1553569200) ENGINE = InnoDB,
PARTITION p2019_03_26 VALUES LESS THAN (1553655600) ENGINE = InnoDB,
PARTITION p2019_03_27 VALUES LESS THAN (1553742000) ENGINE = InnoDB,
PARTITION p2019_03_28 VALUES LESS THAN (1553828400) ENGINE = InnoDB,
PARTITION p2019_03_29 VALUES LESS THAN (1553914800) ENGINE = InnoDB,
PARTITION p2019_03_30 VALUES LESS THAN (1554001200) ENGINE = InnoDB,
PARTITION p2019_03_31 VALUES LESS THAN (1554087600) ENGINE = InnoDB,
PARTITION p2019_04_01 VALUES LESS THAN (1554174000) ENGINE = InnoDB) */

Acceda a la consola MySQL y verifique que el sistema haya creado 10 meses de tendencias antes de tiempo.

# mysql -u root -p

use zabbix;
show create table trends;

/*!50100 PARTITION BY RANGE ( clock)
(PARTITION p2019_03 VALUES LESS THAN (1554087600) ENGINE = InnoDB,
PARTITION p2019_04 VALUES LESS THAN (1556679600) ENGINE = InnoDB,
PARTITION p2019_05 VALUES LESS THAN (1559358000) ENGINE = InnoDB,
PARTITION p2019_06 VALUES LESS THAN (1561950000) ENGINE = InnoDB,
PARTITION p2019_07 VALUES LESS THAN (1564628400) ENGINE = InnoDB,
PARTITION p2019_08 VALUES LESS THAN (1567306800) ENGINE = InnoDB,
PARTITION p2019_09 VALUES LESS THAN (1569898800) ENGINE = InnoDB,
PARTITION p2019_10 VALUES LESS THAN (1572577200) ENGINE = InnoDB,
PARTITION p2019_11 VALUES LESS THAN (1575165600) ENGINE = InnoDB,
PARTITION p2019_12 VALUES LESS THAN (1577844000) ENGINE = InnoDB,
PARTITION p2020_01 VALUES LESS THAN (1580522400) ENGINE = InnoDB) */ |

Ahora, programemos el script Perl para que se ejecute diariamente.

# crontab -e

1  0  *  *  * /downloads/scripts/zabbix_partition_creator.pl

¡Felicidades! Ha particionado las tablas de la base de datos MySQL de Zabbix.