क्या आप सीखना चाहते हैं कि ज़ैबिक्स डेटाबेस विभाजन कैसे करें? इस ट्यूटोरियल में, हम आपको दिखाने जा रहे हैं कि उबंटू लिनक्स चलाने वाले कंप्यूटर पर Zabbix MySQL डेटाबेस को कैसे विभाजित किया जाए।

• ज़ैबिक्स संस्करण: 4.0.5
• लिनक्स: उबंटू 18.04
• MySQL: Ver 14.14 Distrib 5.7.25

हमारा ट्यूटोरियल एक बिल्कुल नया ज़ैबिक्स इंस्टॉलेशन मानता है।

हार्डवेयर सूची:

निम्न अनुभाग इस ज़ैबिक्स ट्यूटोरियल बनाने के लिए उपयोग किए जाने वाले उपकरणों की सूची प्रस्तुत करता है।

ऊपर सूचीबद्ध हार्डवेयर का हर टुकड़ा अमेज़न की वेबसाइट पर पाया जा सकता है।

Zabbix Playlist:

इस पृष्ठ पर, हम ज़ैबिक्स इंस्टॉलेशन से संबंधित वीडियो की सूची तक त्वरित पहुंच प्रदान करते हैं।

हमारे youtube चैनल को सब्सक्राइब करना न भूलें FKIT.

Zabbix संबंधित ट्यूटोरियल:

इस पृष्ठ पर, हम ज़ैबिक्स इंस्टॉलेशन से संबंधित ट्यूटोरियल की सूची तक त्वरित पहुंच प्रदान करते हैं।

ट्यूटोरियल – Zabbix डेटाबेस विभाजन

आवश्यक सॉफ़्टवेयर स्थापित करने के लिए निम्न कमांड का उपयोग करें।

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

हमें Zabbix डेटाबेस से निम्न तालिकाओं को विभाजित करना होगा:

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

आपके Zabbix सर्वर को शायद पहले से ही अपने डेटाबेस के भीतर निगरानी से जानकारी है।

MySQL कंसोल को एक्सेस करें और ऊपर सूचीबद्ध 7 टेबल के लिए ज़ैबिक्स सबसे पुरानी प्रविष्टि तिथि सत्यापित करें:

# 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`;

इनमें से प्रत्येक के लिए MySQL कमांड, आउटपुट कुछ इस तरह होना चाहिए:

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

जरूरी! तालिकाओं में से प्रत्येक के लिए प्रदर्शित तिथि का ध्यान रखें।

अब, इतिहास सारणी के प्रत्येक भाग को तिथि के अनुसार विभाजित करें:

सबसे पहले, इतिहास तालिका को विभाजित करते हैं।

# 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);

हमारे उदाहरण में, p2019_03_22 नामक एक फ़ाइल में 2019-03-23 से पहले सभी MySQL जानकारी होगी।

यदि आपकी लक्ष्य तिथि 2019-03-22 है, तो आपको 2019-03-23 से पहले सब कुछ दर्ज करना होगा

दूसरा, आइए 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);

तीसरा, आइए 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);

चौथा, आइए 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);

पांचवां, आइए 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);

अब, चलिए हर एक ट्रेंड टेबल को महीने के अनुसार विभाजित करते हैं:

सबसे पहले, चलन तालिका को विभाजित करते हैं।

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

हमारे उदाहरण में, p2019_03 नामक फ़ाइल में 2019-04-01 से पहले सभी MySQL जानकारी होगी।

यदि आपकी लक्ष्य तिथि 2019-03 है, तो आपको 2019-04-01 से पहले सब कुछ दर्ज करना होगा।

दूसरा, चलिए ट्रेंड्स_इंट टेबल को विभाजित करते हैं।

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

Zabbix डेटाबेस विभाजन सफलतापूर्वक बनाए गए थे।

ट्यूटोरियल – Zabbix डेटाबेस विभाजन स्क्रिप्ट

हम निम्नलिखित कार्यों को करने के लिए एक पर्ल स्क्रिप्ट का उपयोग करने जा रहे हैं:

सेवा को रोकने के लिए समय से पहले MySQL डेटाबेस विभाजन के 10 दिन बनाएं।

पुराने MySQL विभाजन को हटाएं जिनकी अब आवश्यकता नहीं है।

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

यहाँ 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)”);
}

आपको अपने 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’;

हमारे उदाहरण में, हम zabbix MySQL यूज़रनेम और kamisama123 MySQL पासवर्ड का उपयोग कर रहे हैं।

हमारे उदाहरण में, हम इतिहास तालिका सामग्री के 30 दिन रख रहे हैं।

हमारे उदाहरण में, हम 2 महीने के ट्रेंड्स टेबल कंटेंट को रख रहे हैं।

हमारे उदाहरण में, हमने अमेरिका / साओ_पाउलो तारीख का समय निर्धारित किया है।

अब, आपको त्रुटियों के बिना स्क्रिप्ट को मैन्युअल रूप से चलाने की आवश्यकता है।

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

MySQL कंसोल पर पहुंचें और इसे सत्यापित करें कि सिस्टम ने इतिहास विभाजन के 10 दिन पहले बनाया था।

# 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) */

MySQL कंसोल तक पहुँचें और इसे सत्यापित करें कि सिस्टम ने समय से पहले 10 महीने के ट्रेंड विभाजन को बनाया है।

# 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) */ |

अब, दैनिक चलाने के लिए पर्ल स्क्रिप्ट को शेड्यूल करें।

# crontab -e

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

बधाई हो! आपने Zabbix MySQL Database टेबल को विभाजित कर दिया है।